Home

Script: dzen_notifier.pl

Notify dzen when a private message is received. (for WeeChat ≥ 0.4.3, requires: IO::Handle)
Author: apendragon, version 0.2, Artistic 2.0 — added: 2015-06-14
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
# Copyright (c) 2015 by apendragon <cpandragon@gmail.com>
# Released under Artistic License (2.0).

use strict;
use IO::Handle;
use constant {
  _SCRIPT_NAME    => 'dzen_notifier',
  _VERSION        => '0.2',
  _AUTHOR         => 'apendragon',
  _LICENSE        => 'artistic_2',
  _DESC           => 'weechat dzen notifier script',
  _SHUTDOWN_F     => 'shutdown',
  _CHARSET        => 'UTF-8',
  _BITLBEE_CHAN   => '&bitlbee',
  _UNKNOWN_SENDER => 'stranger',
  _DEBUG          => 0,
};

my %options = (
  icon     => '', # example: '^i(/home/johndoe/.dzen/icons/xbm8x8/cat.xbm)',
  dzen_cmd => "dzen2 -ta l -h 18 -fn 'snap' -bg '#111111' -fg '#b3b3b3' -w 200 -x 1000",
);

weechat::register(_SCRIPT_NAME(), _AUTHOR(), _VERSION(), _LICENSE(), _DESC(), _SHUTDOWN_F(), _CHARSET());

=head1 NAME

dzen_notifier.pl

=head1 SYNOPSIS

dzen_notifier.pl

does not take any args.

Just put it in ~/.weechat/perl/autoload dir or load it manually with /script

=head1 DESCRIPTION

dzen_notifier.pl perl script will notify dzen when you receive a private message in weechat.

The form of notification is C<${icon} [${nb_pv_sender}] ${last_sender} (${nb_msg_of_last_sender})>

where

=over 4

=item * C<${icon}> is a parameterized icon or nothing by default I<(see icon option)>

=item * C<${nb_pv_sender}> is number of unread buffers of private messages

=item * C<${last_sender}> the nick of the last sender who wrote you a private message you did not read or C<stranger>
        if the last sender is not in your bitlbee buddy list I<(see L</Bitlbee> for more details)>.

=item * C<${nb_msg_of_last_sender}> is number of unread messages in your last sender buffer

=back

See L</EXAMPLE>.

=head2 Set private message as read

If you switch to private message buffer that has been notified, it will automatically be removed from stack of private messages notified.
Then C<${nb_pv_sender}> will be decreased, C<${last_sender}> will switch to preceding last sender who wrote you a private message
you did not read (or nothing if there is not), and C<${nb_msg_of_last_sender}> will begin the number of unread messages of this
preceding sender (or nothing if there is not).

=head2 Bitlbee

If you use L<bitlbee|http://www.bitlbee.org>, you know that if you receive private message of somebody who is not in your buddy list, it will
appear in C<&bitlbee> buffer. dzen_notifier.pl handles this case and will notify dzen with C<stranger> private message notification.
C<stranger> nickname is used because more than one unknow body may send you private message at the same time in this buffer. All these
private message notifications will be removed from private messages stack when you will swich to C<&bitlbee> buffer.

=head2 OPTIONS

Options can directly be set in C<%options> hash.

=over 4

=item * C<dzen_cmd> is the dzen command where dzen_notifier.pl will pipe output notifications.

By default it is

        dzen2 -ta l -h 18 -fn 'snap' -bg '#111111' -fg '#b3b3b3' -w 200 -x 1000.

Of course you have to customize it with your own dzen settings, like x position, font, width, etc.

=item * C<icon> is the icon path you want to use front of your notification.

By example

        ^i(/home/johndoe/.dzen/icons/xbm8x8/cat.xbm)

=back

=head1 EXAMPLE

if dzen notification looks like

C<[4] johndoe (2)>

it means you have C<4> private message buffers you have not already read, the last private message you received is in C<johndoe> buffer,
and he wrote C<2> unread messages in this buffer.

=head1 AUTHOR

Thomas Cazali

=head1 SOURCE

The source code repository for C<dzen_notifier.pl> can be found at L<https://github.com/apendragon/weechat-dzen-notifier>

=head1 BUGS

Please report any bugs or feature requests to L<https://github.com/apendragon/weechat-dzen-notifier/issues>.

=head1 SUPPORT

You can find documentation for this script at

L<https://github.com/apendragon/weechat-dzen-notifier/wiki>

=over 4

=item * github repository issues tracker (report bugs here)

L<https://github.com/apendragon/weechat-dzen-notifier/issues>

=back

=head1 LICENSE AND COPYRIGHT

Copyright 2015 Thomas Cazali.

This program is free software; you can redistribute it and/or modify it
under the terms of the the Artistic License (2.0). You may obtain a
copy of the full license at:

L<http://www.perlfoundation.org/artistic_license_2_0>

Any use, modification, and distribution of the Standard or Modified
Versions is governed by this Artistic License. By using, modifying or
distributing the Package, you accept this license. Do not use, modify,
or distribute the Package, if you do not accept this license.

If your Modified Version has been derived from a Modified Version made
by someone other than you, you are nevertheless required to ensure that
your Modified Version complies with the requirements of this license.

This license does not grant you the right to use any trademark, service
mark, tradename, or logo of the Copyright Holder.

This license includes the non-exclusive, worldwide, free-of-charge
patent license to make, have made, use, offer to sell, sell, import and
otherwise transfer the Package with respect to any patent claims
licensable by the Copyright Holder that are necessarily infringed by the
Package. If you institute patent litigation (including a cross-claim or
counterclaim) against any party alleging that the Package constitutes
direct or contributory patent infringement, then this Artistic License
to you shall terminate on the date that such litigation is filed.

Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER
AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY
YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR
CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR
CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=cut

open my ($io_fh), "|$options{dzen_cmd}";
$io_fh->autoflush(1);
my %buffered_pv_msg = ();
my @stacked_notif = ();

weechat::hook_print('', '', '', 1, 'print_author_and_count_priv_msg', '');
weechat::hook_signal('buffer_switch', 'unnotify_on_private', '');

sub get_msg_sender {
  my ($tags) = @_;
  my $nick = '';
  $nick = $1 if (defined($tags) && $tags =~ m/(?:^|,)nick_([^,]*)(?:,|$)/);
  $nick;
}

sub is_my_message {
  my ($tags, $buffer) = @_;
  my $my_nick = weechat::buffer_get_string($buffer, 'localvar_nick');
  my $nick = get_msg_sender($tags);
  $nick eq $my_nick;
}

sub is_private_message {
  my ($buffer, $tags) = @_;
  my $private_buff = weechat::buffer_get_string($buffer, 'localvar_type') eq 'private';
  $private_buff && $tags =~ m/(?:^|,)notify_private(?:,|$)/;
}

sub is_bitlbee_private_message {
  my ($buffer, $tags, $highlight, $message) = @_;
  my $bitlbee_buff = weechat::buffer_get_string($buffer, 'localvar_channel') eq _BITLBEE_CHAN();
  my $my_nick = weechat::buffer_get_string($buffer, 'localvar_nick');
  $highlight && $bitlbee_buff && $message =~ m/^$my_nick:/;
}

sub notify {
  my ($sender) = @_;
  my $count = scalar keys %buffered_pv_msg;
  $count ? print $io_fh "$options{icon} [$count] $sender ($buffered_pv_msg{$sender})\n" : print $io_fh "\n";
  weechat::WEECHAT_RC_OK;
}

sub notify_on_private {
  my ($buffer, $tags, $highlight, $message) = @_;
  my $is_bitlbee_pv_msg = is_bitlbee_private_message($buffer, $tags, $highlight, $message);
  my $closure = sub {
    my $sender = $is_bitlbee_pv_msg ? _UNKNOWN_SENDER() : get_msg_sender($tags);
    rm_from_stack($sender);
    push(@stacked_notif, $sender);
    $buffered_pv_msg{$sender}++;
    notify $sender;
  };
  ($is_bitlbee_pv_msg || is_private_message($buffer, $tags)) ? $closure->() : weechat::WEECHAT_RC_OK;
}

sub print_author_and_count_priv_msg {
  my ($data, $buffer, $date, $tags, $displayed, $highlight, $prefix, $message) = @_;
  my $dispatch = {
    0 => sub { weechat::WEECHAT_RC_OK }, # return if message is filtered
    1 => sub {
      is_my_message($tags, $buffer)
        ? weechat::WEECHAT_RC_OK
        : notify_on_private($buffer, $tags, $highlight, $message);
    },
  };
  $dispatch->{$displayed}->();
}

sub unnotify {
  my ($sender) = @_;
  rm_sender_notif($sender);
  scalar(@stacked_notif) ? notify($stacked_notif[-1]) : notify();
}

sub unnotify_on_private {
  my ($signal, $type_data, $signal_data) = @_;
  my $type=weechat::buffer_get_string($signal_data, 'localvar_type');
  my $channel=weechat::buffer_get_string($signal_data, 'localvar_channel');
  my $dispatch = {
    'private'  => sub {
       unnotify($channel);
    },
    'channel' => sub {
      $channel eq _BITLBEE_CHAN() && $buffered_pv_msg{_UNKNOWN_SENDER()}
        ? unnotify(_UNKNOWN_SENDER())
        : weechat::WEECHAT_RC_OK;
    },
  };
  ($dispatch->{$type} || sub { weechat::WEECHAT_RC_OK })->();
}

sub rm_from_stack {
  my ($sender) = @_;
  my @stack = ();
  foreach (@stacked_notif) { push(@stack, $_) if ($_ ne $sender) }
  @stacked_notif = @stack;
}

sub rm_sender_notif {
  my ($sender) = @_;
  delete($buffered_pv_msg{$sender});
  rm_from_stack($sender);
}

sub shutdown {
  #weechat::log_print("shutdown") if _DEBUG();
  close $io_fh;
}