|| [=][=]", - "f file : show options for a file\n". - "s section : show options for a section\n". - "text : show options with 'text' in name\n". - weechat::config_string($options_iset{"value_search_char"})."text : show options with 'text' in value\n". - weechat::config_string($options_iset{"value_search_char"}).weechat::config_string($options_iset{"value_search_char"})."text : show options with exact 'text' in value\n\n". + "f file : show options for a file\n". + "s section: show options for a section\n". + "text : show options with 'text' in name\n". + weechat::config_string($options_iset{"value_search_char"})."text : show options with 'text' in value\n". + weechat::config_string($options_iset{"value_search_char"}).weechat::config_string($options_iset{"value_search_char"})."text : show options with exact 'text' in value\n\n". "Keys for iset buffer:\n". "f11,f12 : move iset content left/right\n". "up,down : move one option up/down\n". @@ -1363,11 +1355,11 @@ "alt+'v' : toggle help bar on/off\n". "alt+'p' : toggle option \"show_plugin_description\" on/off\n". "\n". - "standard mouse actions:\n". - "wheel up / wheel down : move option up/down\n". - "left-mouse-button : select an option from list\n". - "right-mouse-button : toggle boolean (on/off) or set a new value for option (edit it with command line)\n". - "right-mouse-button + gesture left/right: increase/decrease value (for integer or color)\n". + "Mouse actions:\n". + "wheel up/down : move cursor up/down\n". + "left button : select an option from list\n". + "right button : toggle boolean (on/off) or set a new value for option (edit it with command line)\n". + "right button + drag left/right: increase/decrease value (for integer or color)\n". "\n". "Examples:\n". " show options for file 'weechat'\n". diff -Nru weechat-scripts-20130123/perl/isgd.pl weechat-scripts-20131007/perl/isgd.pl --- weechat-scripts-20130123/perl/isgd.pl 2013-01-23 19:00:26.000000000 +0000 +++ weechat-scripts-20131007/perl/isgd.pl 2013-10-07 12:14:57.000000000 +0000 @@ -1,5 +1,5 @@ # -# Copyright (C) 2011-2012 stfn +# Copyright (C) 2011-2013 stfn # # 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 @@ -27,44 +27,80 @@ my %SCRIPT = ( name => 'isgd', author => 'stfn ', - version => '0.3', + version => '0.6', license => 'GPL3', - desc => 'Shorten URLs with is.gd on command', + desc => 'Shorten URLs with is.gd on demand or automatically', opt => 'plugins.var.perl', ); -my %OPTIONS = ( - color => 'white', # color used for printing short URLs +my %OPTIONS_DEFAULT = ( + 'color' => ['white', 'Color used for printing shortened URLs'], + 'auto' => ['off', 'Shorten all incoming URLs automatically'], ); +my %OPTIONS = (); my $SHORTENER_URL = "http://is.gd/create.php?format=simple&url="; +my $SHORTENER_BASE = "http://is.gd/"; my $TIMEOUT = 30 * 1000; -my %LOOKUP; +my $CACHE_MAX_SIZE = 128; +my (%LOOKUP, %CACHE); weechat::register($SCRIPT{"name"}, $SCRIPT{"author"}, $SCRIPT{"version"}, $SCRIPT{"license"}, $SCRIPT{"desc"}, "", ""); +weechat::hook_print("", "", "", 1, "print_cb", ""); weechat::hook_command($SCRIPT{"name"}, $SCRIPT{"desc"}, - "[ ...]\n" . - " []\n" . - " []\n", + "[-o] [||]\n", + " -o: send shortened URL to current buffer as input\n" . " URL: URL to shorten (multiple URLs may be given)\n" . " number: shorten up to n last found URLs in current buffer\n" . "partial expr: shorten last found URL in current buffer which matches the given partial expression\n" . "\nWithout any URL arguments, the last found URL in the current buffer will be shortened.\n\n" . "Examples:\n" . + " /isgd\n" . " /isgd http://google.de\n" . + " /isgd -o http://slashdot.org/\n" . " /isgd 3\n" . " /isgd youtube", "", "command_cb", ""); init_config(); +# +# Catch printed messages +# +sub print_cb +{ + my ($data, $buffer, $date, $tags, $displayed, $highlight, $prefix, $message) = @_; + my @URLs; + + if ($OPTIONS{auto} ne "on" || $tags =~ /\bno_log\b/) { + return weechat::WEECHAT_RC_OK; + } + + # Find URLs + @URLs = grep_urls($message); + + # Process all found URLs + shorten_urls(\@URLs, $buffer); + + return weechat::WEECHAT_RC_OK; +} + +# +# /isgd +# sub command_cb { my ($data, $buffer, $args) = @_; + my $send = 0; my @URLs; - # If URLs were provided in command arguments, shorten them - while ($args =~ m{(https?://\S+)}gi) { - push(@URLs, $1); + # Check for command switch + if ($args =~ /^-o/) { + $args =~ s/^-o//; + $send = 1; } + + # If URLs were provided in command arguments, shorten them + @URLs = grep_urls($args); + # Otherwise search backwards in lines of current buffer if (@URLs == 0) { # @@ -74,69 +110,143 @@ # my $match = ""; $match = $1 if ($count == 0 && $args =~ /^(\S+)$/); - - my $infolist = weechat::infolist_get("buffer_lines", $buffer, ""); $count = 1 if ($count == 0); - while (weechat::infolist_prev($infolist) == 1) { - my $message = weechat::infolist_string($infolist, "message"); - while ($message =~ m{(https?://\S+)}gi) { - my $url = $1; - if ($match eq "" || $url =~ /\Q$match\E/i) { - push(@URLs, $url) unless ($url =~ m{^https?://is\.gd/}gi); + + # Iterate through lines of buffer backwards + my $own_lines = weechat::hdata_pointer(weechat::hdata_get("buffer"), $buffer, "own_lines"); + if ($own_lines) { + my $line = weechat::hdata_pointer(weechat::hdata_get("lines"), $own_lines, "last_line"); + my $hdata_line = weechat::hdata_get("line"); + my $hdata_line_data = weechat::hdata_get("line_data"); + while ($line) { + my $data = weechat::hdata_pointer($hdata_line, $line, "data"); + if ($data) { + my $message = weechat::hdata_string($hdata_line_data, $data, "message"); + my $tags = weechat::hdata_string($hdata_line_data, $data, "tags"); + + foreach (grep_urls($message)) { + my $url = $_; + if ($match eq "" || $url =~ /\Q$match\E/i) { + push(@URLs, $url) unless ($tags =~ /\bno_log\b/); + } + } + last if (@URLs >= $count); } + $line = weechat::hdata_move($hdata_line, $line, -1); } - last if (@URLs >= $count); } - weechat::infolist_free($infolist); + } + # Now process all found URLs + shorten_urls(\@URLs, $buffer, $send); + + return weechat::WEECHAT_RC_OK; +} + +# +# Shortens a list of URLs +# +sub shorten_urls($$$) +{ + my @URLs = @{$_[0]}; + my $buffer = $_[1]; + my $send = $_[2]; + foreach (@URLs) { - my $cmd = "url:$SHORTENER_URL" . CGI::escape($_); - $LOOKUP{$cmd} = $_; - weechat::hook_process($cmd, $TIMEOUT, "process_cb", $buffer); + my $url = $_; + my $cmd = "url:$SHORTENER_URL" . CGI::escape($url); + $LOOKUP{$cmd} = $url; + + if (my $url_short = $CACHE{$cmd}) { + if ($send) { + weechat::command($buffer, $url_short); + } else { + print_url($buffer, $url_short, $url); + } + } else { + weechat::hook_process($cmd, $TIMEOUT, $send ? "url_send_cb" : "url_cb", $buffer); + } + } +} + +sub url_cb +{ + my ($data, $command, $return_code, $out, $err) = @_; + my $buffer = $data; + my $url_short = $out; + + if ($return_code == 0 && $url_short) { + cache_url($command, $url_short); + print_url($buffer, $url_short, $LOOKUP{$command}); } return weechat::WEECHAT_RC_OK; } -sub process_cb +sub url_send_cb { my ($data, $command, $return_code, $out, $err) = @_; my $buffer = $data; - my $url = $out; + my $url_short = $out; - if ($return_code == 0 && $url) { - print_url($buffer, $url, $LOOKUP{$command}); + if ($return_code == 0 && $url_short) { + cache_url($command, $url_short); + weechat::command($buffer, $url_short); } return weechat::WEECHAT_RC_OK; } +sub grep_urls($) +{ + my $str = $_[0]; + my @urls; + while ($str =~ m{(https?://\S+)}gi) { + push(@urls, $1) unless ($1 =~ /^\Q$SHORTENER_BASE\E/); + } + return @urls; +} + sub print_url($$$) { - my ($buffer, $url, $cmd) = @_; - my $domain = ""; - $domain = $1 if ($cmd =~ m{^https?://([^/]+)}gi); - weechat::print_date_tags($buffer, 0, "no_log", weechat::color($OPTIONS{color}) . "$url ($domain)"); + my ($buffer, $url_short, $cmd) = @_; + my $domain = ""; + $domain = $1 if ($cmd =~ m{^https?://([^/]+)}gi); + weechat::print_date_tags($buffer, 0, "no_log", weechat::color($OPTIONS{color}) . "$url_short ($domain)"); +} + +sub cache_url($$) +{ + my ($command, $url_short) = @_; + %CACHE = () if (keys(%CACHE) > $CACHE_MAX_SIZE); + $CACHE{$command} = $url_short; } +# +# Handle config stuff +# sub init_config { weechat::hook_config("$SCRIPT{'opt'}.$SCRIPT{'name'}.*", "config_cb", ""); - foreach my $option (keys %OPTIONS) { + my $version = weechat::info_get("version_number", "") || 0; + foreach my $option (keys %OPTIONS_DEFAULT) { if (!weechat::config_is_set_plugin($option)) { - weechat::config_set_plugin($option, $OPTIONS{$option}); + weechat::config_set_plugin($option, $OPTIONS_DEFAULT{$option}[0]); + $OPTIONS{$option} = $OPTIONS_DEFAULT{$option}[0]; } else { $OPTIONS{$option} = weechat::config_get_plugin($option); } + if ($version >= 0x00030500) { + weechat::config_set_desc_plugin($option, $OPTIONS_DEFAULT{$option}[1]." (default: \"".$OPTIONS_DEFAULT{$option}[0]."\")"); + } } } sub config_cb { my ($pointer, $name, $value) = @_; - $name = substr($name, length("$SCRIPT{'opt'}.$SCRIPT{'name'}."), length($name)); + $name = substr($name, length("$SCRIPT{opt}.$SCRIPT{name}."), length($name)); $OPTIONS{$name} = $value; - return weechat::WEECHAT_RC_OK; } diff -Nru weechat-scripts-20130123/perl/join2fast.pl weechat-scripts-20131007/perl/join2fast.pl --- weechat-scripts-20130123/perl/join2fast.pl 2013-01-23 19:00:27.000000000 +0000 +++ weechat-scripts-20131007/perl/join2fast.pl 2013-10-07 12:14:58.000000000 +0000 @@ -1,4 +1,4 @@ -# Copyright (C) 2012 Stefan Wold +# Copyright (C) 2012-2013 Stefan Wold # # 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 @@ -14,39 +14,67 @@ # along with this program. If not, see . # # -# Automatically join channels on UnderNET that get throttled due to "Target change too fast". +# Source available on GitHUB: https://github.com/Ratler/join2fast +# +# +# Automatically queue and join channels on UnderNET that get throttled due to "Target change too fast". +use 5.010; +use POSIX qw/strftime/; use strict; use warnings; my $SCRIPT_NAME = "join2fast"; -my $VERSION = "0.5"; -my $weechat_version = ""; +my $VERSION = "0.8.1"; my %timers; +my %next_join; my %channel_list; +my %default_options = ('timer_delay' => ['4', 'default delay in seconds added to the timer before trying to join the next channel in the list'], + 'date_format' => ['%H:%M:%S', 'date and time format for time of the next join. Used by join2fast bar item.'], + 'hide_event_msg' => ['on', 'hide target change too fast message']); +my %options = (); # Register script weechat::register($SCRIPT_NAME, "Ratler ", $VERSION, "GPL3", - "Automatically join channels on UnderNET that get throttled due to \"Target change too fast\"", "", ""); + "Automatically join channels on UnderNET that get throttled due to \"Target change too fast\"", "clear_all_on_script_unload", ""); -$weechat_version = weechat::info_get("version_number", ""); +my $weechat_version = weechat::info_get("version_number", "") || 0; if ($weechat_version < 0x00030200) { weechat::print("", weechat::prefix("error") . "$SCRIPT_NAME: requires weechat >= v0.3.2"); weechat::command("", "/wait 1ms /perl unload $SCRIPT_NAME"); } -# Callback for "Target changed too fast" events -weechat::hook_signal("*,irc_raw_in_439", "event_439_cb", ""); +# Initialize config +init_config(); -sub event_439_cb { - # $_[1] - name of the event - # $_[2] - the message (:server 439 nick #channel :Target change too fast. Please wait 17 seconds.) +# Hook command /j2f +weechat::hook_command("j2f", + "list/clear join2fast queue", + "[list] | [clear [server]]", + " list: list current queues\n". + " clear [server]: clear all queues or the queue for a specific server", + "list || clear %(irc_servers)", + "j2f_command_cb", ""); - my $server = (split ",", $_[1])[0]; - my @msg = split " ", $_[2]; - my $channel = $msg[3]; - my $delay = $msg[10]; +# Hook server disconnect to clear active queue +weechat::hook_signal("irc_server_disconnected", "clear_queue_on_disconnect", ""); + +# Callback for "Target change too fast" events +weechat::hook_modifier("irc_in_439", "event_439_cb", ""); + +# Setup bar item +weechat::bar_item_new($SCRIPT_NAME, "bar_cb", ""); + +sub event_439_cb { + my ($data, $modifier, $server, $string) = @_; + # $string - the message (:server 439 nick #channel :Target change too fast. Please wait 17 seconds.) + my $channel = (split " ", $string)[3]; + my $delay = (split " ", $string)[10]; + + # Return if target is not a channel + # TODO: Add option to allow queueing private messages + return $string unless $channel =~ /^(#|&)/; # Check if channel has been already added or add it if (!exists($channel_list{$server}) or ((ref $channel_list{$server} eq 'ARRAY') and !($channel ~~ @{$channel_list{$server}}))) { @@ -54,9 +82,36 @@ } # Reset timer to the last delay received - weechat::unhook($timers{$server}) if $timers{$server}; + weechat::unhook($timers{$server}) if exists($timers{$server}); + + $next_join{$server} = {timestamp => time() + $delay + 2}; $timers{$server} = weechat::hook_timer(($delay + 2) * 1000, 0, 1, "join_channel_cb", $server); + # Update bar + weechat::bar_item_update($SCRIPT_NAME); + + return lc($options{hide_event_msg}) eq 'off' ? $string : ""; +} + +sub clear_queue_on_disconnect { + my $server = $_[2]; + + if (exists($channel_list{$server})) { + delete $channel_list{$server}; + delete $next_join{$server}; + weechat::bar_item_update($SCRIPT_NAME); + } + + return weechat::WEECHAT_RC_OK; +} + +sub clear_all_on_script_unload { + foreach my $server (keys %timers) { + weechat::unhook($timers{$server}); + } + undef %channel_list; + undef %next_join; + return weechat::WEECHAT_RC_OK; } @@ -66,30 +121,96 @@ if ((ref $channel_list{$server} eq 'ARRAY') and scalar @{$channel_list{$server}} > 0) { my $channel = pop @{$channel_list{$server}}; - # Save current buffer - my $buffer_ptr = weechat::current_buffer(); - my $buffer_name = weechat::buffer_get_string($buffer_ptr, "name"); - if ($weechat_version >= 0x00040000) { weechat::command("", "/join -noswitch -server $server $channel"); } else { + # Save current buffer + my $buffer_ptr = weechat::current_buffer(); + my $buffer_name = weechat::buffer_get_string($buffer_ptr, "name"); + weechat::command("", "/join -server $server $channel"); - } - # Switch back to the old buffer (a bit flakey) - disabled when irc.look.buffer_switch_join is set to off - # or weechat version >= 0.4.0 - my $option = weechat::config_get("irc.look.buffer_switch_join"); - if (($weechat_version < 0x00040000) and weechat::config_boolean($option)) { - weechat::command("", "/wait 1s /buffer $buffer_name"); + # Switch back to the old buffer (a bit flakey) - disabled when irc.look.buffer_switch_join is set to off + my $option = weechat::config_get("irc.look.buffer_switch_join"); + if (weechat::config_boolean($option)) { + weechat::command("", "/wait 1s /buffer $buffer_name"); + } } # Setup a new timer if ((ref $channel_list{$server} eq 'ARRAY') and scalar @{$channel_list{$server}} > 0) { - $timers{$server} = weechat::hook_timer(4 * 1000, 0, 1, "join_channel_cb", $server); + $timers{$server} = weechat::hook_timer($options{timer_delay} * 1000, 0, 1, "join_channel_cb", $server); + $next_join{$server} = {timestamp => time() + $options{timer_delay}}; } else { delete $channel_list{$server}; + delete $next_join{$server}; } } + # Update bar + weechat::bar_item_update($SCRIPT_NAME); + return weechat::WEECHAT_RC_OK; } + +sub bar_cb { + my $queue_size = 0; + + foreach my $server (keys %channel_list) { + $queue_size += scalar @{$channel_list{$server}}; + } + + return $queue_size > 0 ? "Q: $queue_size N: " . get_next_join_time() : ""; +} + +sub get_next_join_time { + my $key = (sort {$next_join{$a}->{timestamp} <=> $next_join{$b}->{timestamp}} keys (%next_join))[0]; + return strftime($options{date_format}, localtime($next_join{$key}{timestamp})); +} + +sub j2f_command_cb { + my ($data, $buffer, $args) = @_; + my ($option, $arg) = split " ", $args; + + if ($option eq 'list') { + if (scalar (keys %channel_list) > 0) { + foreach my $server (keys %channel_list) { + weechat::print("", "$SCRIPT_NAME: Throttled channels on '$server': " . join(', ', @{$channel_list{$server}})); + } + } else { + weechat::print("", "$SCRIPT_NAME: no channels currently queued."); + } + } elsif ($option eq 'clear') { + if (defined($arg)) { + if (exists($timers{$arg})) { + weechat::unhook($timers{$arg}); + delete $timers{$arg}; + } + delete $channel_list{$arg}; + delete $next_join{$arg}; + } else { + foreach my $server (keys %channel_list) { + if (exists($timers{$server})) { + weechat::unhook($timers{$server}); + delete $timers{$server}; + } + delete $channel_list{$server}; + delete $next_join{$server}; + } + } + weechat::bar_item_update($SCRIPT_NAME); + } + return weechat::WEECHAT_RC_OK; +} + +sub init_config { + foreach my $option (keys %default_options) { + if (!weechat::config_is_set_plugin($option)) { + weechat::config_set_plugin($option, $default_options{$option}[0]); + $options{$option} = $default_options{$option}[0]; + } else { + $options{$option} = weechat::config_get_plugin($option); + } + weechat::config_set_desc_plugin($option, $default_options{$option}[1] . " (default: " . $default_options{$option}[0] . ")") if ($weechat_version >= 0x00030500); + } +} diff -Nru weechat-scripts-20130123/perl/luanma.pl weechat-scripts-20131007/perl/luanma.pl --- weechat-scripts-20130123/perl/luanma.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/luanma.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,1563 @@ +use strict; use warnings; +$INC{'Encode/ConfigLocal.pm'}=1; +use Encode; +eval { local $SIG{__DIE__}; # silence weechat die handler + require Encode::HanExtra }; # more chinese +eval { local $SIG{__DIE__}; + require Encode::JIS2K }; # more japanese +use Time::Local; + +# luanma.pl is written by Nei +# and licensed under the under GNU General Public License v3 +# or any later version + +# to read the following docs, you can use "perldoc luanma.pl" + +=head1 NAME + +luanma - store more info about encoding of message, and change it with update (weechat edition) + +=head1 SYNOPSIS + +more help for charset troubles + +command is called /lma + +see "/help lma" for usage + +=head1 DESCRIPTION + +luanma will allow you to view received messages as they would appear +when decoded using different charsets. you might know this feature +from your webbrowser. it is useful if you need to understand a message +that was received, but it looks garbled because the sender used +different charset than you. + +as usual, a list of charsets can be defined that will be tried in +consecution until a successful decode is made. + +the charset can be choosen differently for different times in the past +and based on nick and weechat buffer. furthermore, you can use /debug +tags to see which charset was used to decode a message. + +a table of charset rules will be saved to luanma.conf and can be +edited with /lma set command. + +=head1 CAVEATS + +=over + +=item * + +the automatic encoding of outgoing notices is visible on display and +no assessment of success is given, because weechat does not set the +appropriate tag on outgoing notices + +=item * + +in order to not convert all messages as raw, only high bit data +(extended ascii) is encoded. that means the script works fine for +latin variants and utf8, but B for any 7bit-clean encoding or for +national EBCDIC + +=item * + +colours might get mixed up with colorize_nicks script when there is a +nick with the same name as a 2-hex-character encoding (example: +"b2"). One possible workaround is to turn off greedy_matching in +colorize_nicks + +=item * + +no encoding is done when outgoing charset is specified as 'utf8' + +=back + +=head1 BUGS + +=over + +=item * + +splitting of messages is not supported, so if byte-length of message +in utf8 exceeds 510, it will get split by weechat. result is that only +the first part is encoded properly. + +if byte-length of B message exceeds 510, then it will usually +get cut off (exact behaviour depends on IRC server) + +=item * + +the prefix on ACTION messages ('/me') gets recoded for messages that +you send yourself. this will cause problems with utf8 nicknames where +supported + +=back + +=head1 SETTINGS + +the settings are usually found in the + + plugins.var.perl.luanma + +namespace, that is, type + + /set plugins.var.perl.luanma.* + +to see them and + + /set plugins.var.perl.luanma.SETTINGNAME VALUE + +to change a setting C to a new value C. Finally, + + /unset plugins.var.perl.luanma.SETTINGNAME + +will reset a setting to its default value. + +the following settings are available: + +=head2 tags + +white-space separated list of irc_(in_) tags to store raw messages of +(only those can be recoded). see /debug tags + +=head2 encode_warn + +add a warning message into the line displayed on your buffer, when +encoding of outgoing messages fails/is lossy + +=head2 parser + +parser to use for line parsing. valid options: ondemand, async, +full. ondemand will parse lines when displayed on screen (needs parse +on every buffer switch, but fast on load). async and full do not need +to parse lines when switching buffers, but WILL FREEZE your weechat on +/script (re)load and /upgrade. be careful. + +async uses timers to do the parsing which should make it less likely +for you to drop network connection. full will do the parse in one +swipe, so it is faster and the freeze is of shorter duration. + +=cut + +use constant SCRIPT_NAME => 'luanma'; +weechat::register(SCRIPT_NAME, 'Nei ', '0.2', 'GPL3', + 'more flexibility with incoming charset', 'stop_luanma', '') || return; +sub SCRIPT_FILE() { + my $infolistptr = weechat::infolist_get('perl_script', '', SCRIPT_NAME); + my $filename = weechat::infolist_string($infolistptr, 'filename') if weechat::infolist_next($infolistptr); + weechat::infolist_free($infolistptr); + return $filename unless @_; +} + +{ +package Nlib; +# this is a weechat perl library +use strict; use warnings; no warnings 'redefine'; + +## hdh -- hdata helper +## $_[0] - arg pointer or hdata list name +## $_[1] - hdata name +## $_[2..$#_] - hdata variable name +## $_[-1] - hashref with key/value to update (optional) +## returns value of hdata, and hdata name in list ctx, or number of variables updated +sub hdh { + if (@_ > 1 && $_[0] !~ /^0x/ && $_[0] !~ /^\d+$/) { + my $arg = shift; + unshift @_, weechat::hdata_get_list(weechat::hdata_get($_[0]), $arg); + } + while (@_ > 2) { + my ($arg, $name, $var) = splice @_, 0, 3; + my $hdata = weechat::hdata_get($name); + unless (ref $var eq 'HASH') { + $var =~ s/!(.*)/weechat::hdata_get_string($hdata, $1)/e; + (my $plain_var = $var) =~ s/^\d+\|//; + my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); + if ($type eq 'pointer') { + my $name = weechat::hdata_get_var_hdata($hdata, $var); + unshift @_, $name if $name; + } + + my $fn = "weechat::hdata_$type"; + unshift @_, do { no strict 'refs'; + &$fn($hdata, $arg, $var) }; + } + else { + return weechat::hdata_update($hdata, $arg, $var); + } + } + wantarray ? @_ : $_[0] +} + +## hook_dynamic -- weechat::hook something and store hook reference +## $hook_call - hook type (e.g. modifier) +## $what - event type to hook (depends on $hook_call) +## $sub - subroutine name to install +## @params - parameters +sub hook_dynamic { + my ($hook_call, $what, $sub, @params) = @_; + my $caller_package = (caller)[0]; + eval qq{ + package $caller_package; + no strict 'vars'; + \$DYNAMIC_HOOKS{\$what}{\$sub} = + weechat::hook_$hook_call(\$what, \$sub, \@params) + unless exists \$DYNAMIC_HOOKS{\$what} && + exists \$DYNAMIC_HOOKS{\$what}{\$sub}; + }; + die $@ if $@; +} + +## unhook_dynamic -- weechat::unhook something where hook reference has been stored with hook_dynamic +## $what - event type that was hooked +## $sub - subroutine name that was installed +sub unhook_dynamic { + my ($what, $sub) = @_; + my $caller_package = (caller)[0]; + eval qq{ + package $caller_package; + no strict 'vars'; + weechat::unhook(\$DYNAMIC_HOOKS{\$what}{\$sub}) + if exists \$DYNAMIC_HOOKS{\$what} && + exists \$DYNAMIC_HOOKS{\$what}{\$sub}; + delete \$DYNAMIC_HOOKS{\$what}{\$sub}; + delete \$DYNAMIC_HOOKS{\$what} unless \%{\$DYNAMIC_HOOKS{\$what}}; + }; + die $@ if $@; +} + +sub fu8on(@) { + Encode::_utf8_on($_) for @_; wantarray ? @_ : shift +} + +use Pod::Select qw(); +use Pod::Simple::TextContent; + +## get_desc_from_pod -- return setting description from pod documentation +## $file - filename with pod +## $setting - name of setting +## returns description as text +sub get_desc_from_pod { + my $file = shift; + return unless -s $file; + my $setting = shift; + + open my $pod_sel, '>', \my $ss; + Pod::Select::podselect({ + -output => $pod_sel, + -sections => ["SETTINGS/$setting"]}, $file); + + my $pt = new Pod::Simple::TextContent; + $pt->output_string(\my $ss_f); + $pt->parse_string_document($ss); + + my ($res) = $ss_f =~ /^\s*\Q$setting\E\s+(.*)\s*/; + $res +} + +## get_settings_from_pod -- retrieve all settings in settings section of pod +## $file - file with pod +## returns list of all settings +sub get_settings_from_pod { + my $file = shift; + return unless -s $file; + + open my $pod_sel, '>', \my $ss; + Pod::Select::podselect({ + -output => $pod_sel, + -sections => ["SETTINGS//!.+"]}, $file); + + $ss =~ /^=head2\s+(.*)\s*$/mg +} + +1 +} + +use constant CMD_NAME => 'lma'; + +our @nags; +our $nag_tag; +our %nag_modifiers; + +our $CFG_FILE_NAME = weechat::info_get('weechat_dir', '').weechat::info_get('dir_separator', '').SCRIPT_NAME.'.conf'; + +our (@CFG_TABLE, @CFG_TABLE_2); +our @STO = (\(our (%BYTE_MSGS, %ESC_MSG, %MSG_TIME, %MSG_BUF, %MSG_NICK, %MSG_ENC, %MSG_FLT, %MSG_COLOR))); +our (@ENCODE_TABLE, @ENCODE_TABLE2); +our %DEC; +our $GC_COUNT; + +our $GC_LIMIT = 10_000; +our $PARSE_STATS = 987; + +our $ASYNC_PARSE = $PARSE_STATS; +our %ASYNC_BUF; +our $ASYNC_TIMER; + +our @mon = qw(jan feb mar apr may jun jul aug sep oct nov dec); +our %mon = do { my $i = 0; map { $_ => $i++ } @mon }; +our $mon_re = join '|', @mon; + +## esc1 -- escape all endangered characters +## @_ - strings to modify +sub esc1 { + for (@_) { + # need to fix up escape here, weechat kills it + # see grep { weechat::string_remove_color(chr $_, "") ne chr $_ } (000..0177) + # our escape bracket is 020 + s/([^\000-\017\021-\030\035-\175\177])/sprintf "\020%x\020", ord $1/ge; + } +} + +## esc_only -- message needs no recode +## $_[0] - message string to check +## returns bool +sub esc_only { + $_[0] !~ /[^\000-\032\034-\175\177]/ +} + +init_luanma(); + +weechat::hook_config('plugins.var.perl.'.SCRIPT_NAME.'.*', 'default_options', ''); +weechat::hook_signal('buffer_line_added', 'line_sig', ''); +weechat::hook_signal('upgrade', 'restore_lines', ''); +weechat::hook_modifier('input_text_for_buffer', 'auto_encode_mod', ''); +weechat::hook_command(CMD_NAME, 'a better /charset', + (join ' || ', 'list', + 'set [] [-out ]', + 'set -out ', + 'del [-g]', + 'del -out [-g]', + 'save', + 'reload', + 'list_rules', + 'gc', + 'forget -yes', + ), (join "\n", + 'without arguments, the list of keys is displayed', + '', + ' list: show list of current recode rules', + ' set: adds or modifies a recode rule', + ' del: delete one or many recode rules', + ' save: save rules to config file', + ' reload: reload rules from config file', + 'list_rules: list internal rules and pointers (for debug and /debug tags)', + ' gc: remove raw lines from cache that are no longer valid in weechat (this is also done autoatically)', + " forget: forget everything about messages, forget all raw and all ESC messages. be careful, /@{[CMD_NAME]} cannot be used anymore after youx do this!", + '', + ' ts: timestamp at which the rule starts to become effective', + ' the following time specifications are supported:', + ' 1357986420: unix timestamp as output by `date +%s\' (used by weechat internally)', + ' -59 | -59m: relative time, 59 seconds/minutes /', + ' -23h | -1d: 23 hours / 1 day ago', + ' HH:MM:SS : time (hour:minutes:seconds)', + ' Jan01 : date (format: MonDD)', + ' Jan0100:00:00 = midnight on January 1st.', + ' 1: from the beginning on', + ' 0: starting from now', + ' the "del" command additionally supports these specifiers:', + ' *: any time', + ' >ts: rule effective after ts', + ' length $a } keys %DEC; + if ($s =~ s/^\02010\020/\020/) {} + elsif ($s =~ s/^\020($codecs)\020//) { + $s = $DEC{$1}->encode($s, Encode::FB_DEFAULT); # must make best effort here + } + elsif ($p =~ /^PRIVMSG/ && $s =~ /^(\01ACTION )\020($codecs)\020(.*)(\01)$/) { # /me + $s = "\01ACTION ".$DEC{$2}->encode($3, Encode::FB_DEFAULT)."\01"; # avoid upgrade + } + else { + return $_[3] + } + "$p$x$s" +} + +## auto_encode_mod -- add encoding prefixes to buffer input line +## () - modifier handler +## $_[1] - modifier +## $_[3] - content of line before sending +sub auto_encode_mod { + # XXX should do the splitting + my $in = Nlib::fu8on(weechat::string_input_for_buffer($_[3])); + return $_[3] unless $in; # pass through commands + return $_[3] unless exists $nag_modifiers{privmsg}; + return $_[3] if $in =~ /^\020/; # already marked + + my $buf = Nlib::hdh($_[2], 'buffer', 'name'); + + my ($r) = + grep { $buf =~ $_->{buf_re} && $in =~ $_->{pat_re} } @ENCODE_TABLE2; + + return $_[3] unless $r; + return $_[3] if $r->{_}{charset} eq 'utf8'; # XXX + "\020${$r}{_}{charset}\020$in" +} + +## auto_encode_cmd -- add tag to command for encode marker +## () - command_run handler +## $_[0] - forward to which command +## $_[1] - buffer pointer +## $_[2] - command +sub auto_encode_cmd { + # XXX should do the splitting + Encode::_utf8_on($_[2]); + #my @args = split ' ', $_[2]; + my ($pre, $in, $buf); + if ($_[0] eq 'me' && $_[2] =~ /^(\S+\s)(.*)$/i) { + ($pre, $in) = ($1, $2); + $buf = weechat::buffer_get_string($_[1], 'name'); + } + elsif ($_[0] eq 'msg' && $_[2] =~ /^(\S+(?:\s+-server\s+(\S+))?\s+(\S+) )(.*)$/i) { + my ($srv, $targ) = ($2, $3); + ($pre, $in) = ($1, $4); + $srv //= weechat::buffer_get_string($_[1], 'localvar_server'); + $buf = $targ ne '*' ? "$srv.$targ" : weechat::buffer_get_string($_[1], 'name'); + } + elsif ($_[0] eq 'query' && $_[2] =~ /^(\S+(?:\s+-server\s+(\S+))?\s+(\S+) )(\s*\S.*)$/i) { + my ($srv, $targ) = ($2, $3); + ($pre, $in) = ($1, $4); + $srv //= weechat::buffer_get_string($_[1], 'localvar_server'); + $buf = "$srv.$targ"; + } + elsif ($_[0] eq 'wallchops' && $_[2] =~ /^(\S+(?:\s+([#&]\S+))? )(.*)$/i) { + my $targ = $2; + ($pre, $in) = ($1, $3); + $buf = $targ ? weechat::buffer_get_string($_[1], 'localvar_server').'.'.$targ : + weechat::buffer_get_string($_[1], 'name'); + } + elsif ($_[0] eq 'topic' && $_[2] !~ /\s-delete\s*$/i && $_[2] =~ /^(\S+(?:\s+([#&\S+]))? )(.*)$/i) { + my $targ = $2; + ($pre, $in) = ($1, $3); + $buf = $targ ? weechat::buffer_get_string($_[1], 'localvar_server').'.'.$targ : + weechat::buffer_get_string($_[1], 'name'); + } + else { + return weechat::WEECHAT_RC_OK + } + + return weechat::WEECHAT_RC_OK if $in =~ /^\020/; # already marked + + my ($r) = + grep { $buf =~ $_->{buf_re} && $in =~ $_->{pat_re} } @ENCODE_TABLE2; + + return weechat::WEECHAT_RC_OK unless $r; + return weechat::WEECHAT_RC_OK if $r->{_}{charset} eq 'utf8'; # XXX + weechat::command($_[1], "$pre\020${$r}{_}{charset}\020$in"); + return weechat::WEECHAT_RC_OK_EAT +} + + +## find_rule -- find rule to recode this line +## $time - timestamp of line +## $buf - buffer name +## $nick - nick +## returns rule if found or undef +sub find_rule { + my ($time, $buf, $nick) = @_; + my ($r) = + grep { $_->{_}{time} <= $time && $buf =~ $_->{buf_re} && $nick =~ $_->{nick_re} } @CFG_TABLE_2; + $r +} + +## apply_recode -- recode a line, looking up its rule first +## $lp - pointer to 'line' hdata +sub apply_recode { + my $lp = shift; + my $rule = find_rule($MSG_TIME{$lp}, $MSG_BUF{$lp}, $MSG_NICK{$lp})//\undef; + return if $rule == $MSG_FLT{$lp}; + my ($s, $e); + for my $enc ((($rule == \undef) ? () : @{$rule->{_}{charsets}}), 'x') { + $s = $BYTE_MSGS{$lp}; + if ($enc eq 'x') { + esc1($s); + $e = $enc; + last; + } + else { + my $enc2 = $enc; + my $partial = $enc2 =~ s/!$//; + next if $enc2 eq 'hz' && $s =~ /[^\000-\177]/; # hack for hz + # put further hacks here... + + my $t = $DEC{$enc2}->decode($s, Encode::FB_QUIET); # FB_CROAK not reliable + #$t =~ s/[[:cntrl:]]//g; + if (length $t && !length $s) { # decoding succeeds + $s = $t; + $e = $enc2; + last; + } + elsif (length $t && $partial) { + esc1($s); + $s = $t . '' . $s; + $e = $enc2 . '_loss'; + last; + } + } + } + if ($MSG_ENC{$lp} ne $e) { + my @line_data = Nlib::hdh((sprintf '0x%x', $lp), 'line', 'data'); + my @tags = grep { !/^lma_/ } map { Nlib::hdh(@line_data, "$_|tags_array") } + 0 .. Nlib::hdh(@line_data, 'tags_count')-1; + + my @ctrl_res = split "\0", $MSG_COLOR{$lp}, -1; + my $c = 1; + $s =~ s/\01+/$ctrl_res[$c++]/g; + + Nlib::hdh(@line_data, +{ + message => $s, + tags_array => (join ',', (($e eq 'x') ? () : ("lma_$e", (sprintf 'lma_0x%x', $rule))), @tags), + }); + $MSG_ENC{$lp} = $e; + } + $MSG_FLT{$lp} = $rule; +} + +## line_sig -- decode charset previously replaced and fix up outgoing msgs +## () - signal handler +## $_[2] - line ptr +sub line_sig { + my @line_data = Nlib::hdh($_[2], 'line', 'data'); + my $lp = oct $_[2]; + $ASYNC_BUF{$lp} = undef if $ASYNC_TIMER; # we are still in async reread loop, mark this line as seen + return weechat::WEECHAT_RC_OK unless Nlib::hdh(@line_data, 'buffer', 'plugin', 'name') eq 'irc'; + my @tags = map { Nlib::hdh(@line_data, "$_|tags_array") } + 0 .. Nlib::hdh(@line_data, 'tags_count')-1; + return weechat::WEECHAT_RC_OK unless grep /$nag_tag/i, @tags; + + my $message_c = Nlib::hdh(@line_data, 'message'); + return weechat::WEECHAT_RC_OK unless $message_c =~ /\020/; + + my $message = my $message_nc = weechat::string_remove_color($message_c, "\1"); + + if (defined $_[0] && grep { $_ eq 'no_highlight' } @tags) { # might be own msg, $_[0] == undef on history parsing + my $action_pfx_re = qr//; + if (grep { $_ eq 'irc_action' } @tags) { + # XXX might erroneously recode the in-line prefix (utf8 nicks anyone? ircx?!) + $action_pfx_re = qr/\S+ \K/; + } + my $codecs = join '|', map { quotemeta } sort { length $b <=> length $a } keys %DEC; + if ($message =~ /^\02010\020/) {} # fall through + elsif ($message =~ s/^$action_pfx_re\020($codecs)\020//) { + my $dec = $1; + + my @ctrl_res; + if ($message_nc =~ /\01/) { + my $id_control = quotemeta $message_nc; + $id_control =~ s/(\\\01)+/(.+?)/g; + @ctrl_res = $message_c =~ /^()$id_control()$/; + } + + $message_nc =~ s/^$action_pfx_re\020\Q$dec\E\020//; + Encode::_utf8_on($message); + my $s = $DEC{$dec}->decode($DEC{$dec}->encode($message, Encode::FB_DEFAULT), Encode::FB_DEFAULT); + my $not_equal = $s ne $message; + + my $c = 1; + $s =~ s/\01+/$ctrl_res[$c++]/g; + + if ($not_equal && weechat::config_string_to_boolean(weechat::config_get_plugin('encode_warn'))) { + $s .= ' '.weechat::color('chat_prefix_error').'[warning: lossy encode]'; + } + + Nlib::hdh(@line_data, +{ + message => $s, + tags_array => (join ',', "lmaout_$dec", ($not_equal ? "lmaout_loss" : ()), @tags), + }); + + return weechat::WEECHAT_RC_OK + } + } + + # XXX bad hack: \01* might be sprinkled from colorize_nicks, but will mess up later on color restore + $message =~ s/\020\01*([[:xdigit:]]+)\01*\020/chr hex $1/ge || return weechat::WEECHAT_RC_OK; + + my @ctrl_res; + if ($message_nc =~ /\01/) { + my $id_control = quotemeta $message_nc; + $id_control =~ s/(\\\01)+/(.+?)/g; + @ctrl_res = $message_c =~ /^()$id_control()$/; + } + + if (esc_only($message)) { + my $c = 1; + $message =~ s/\01+/$ctrl_res[$c++]/g; + Nlib::hdh(@line_data, +{ message => $message }); + $ESC_MSG{$lp} = undef; + return weechat::WEECHAT_RC_OK + } + + $BYTE_MSGS{$lp} = $message; + $MSG_COLOR{$lp} = join "\0", @ctrl_res; + $MSG_TIME{$lp} = 0+Nlib::hdh(@line_data, 'date'); + $MSG_BUF{$lp} = Nlib::hdh(@line_data, 'buffer', 'name'); + my ($nick_tag) = grep s/^nick_//, @tags; + $MSG_NICK{$lp} = $nick_tag//''; + $MSG_ENC{$lp} = 'x'; + $MSG_FLT{$lp} = \undef; + + apply_recode($lp); + + if (defined $GC_LIMIT && ++$GC_COUNT > $GC_LIMIT) { + gc_lines('int'); + $GC_COUNT = 0; + } + + weechat::WEECHAT_RC_OK +} + +## hook_encode_commands -- hook irc commands needed to add encode prefix +## - tag name +sub hook_encode_commands { + if ($_[0] eq 'privmsg') { + (weechat::hook_command_run('/me', 'auto_encode_cmd', 'me'), + weechat::hook_command_run('/msg', 'auto_encode_cmd', 'msg'), + weechat::hook_command_run('/query', 'auto_encode_cmd', 'query'), + ) + } + elsif ($_[0] eq 'notice') { + (weechat::hook_command_run('/notice', 'auto_encode_cmd', 'query'), + weechat::hook_command_run('/wallchops', 'auto_encode_cmd', 'wallchops'), + ) + } + elsif ($_[0] eq 'topic') { + (weechat::hook_command_run('/topic', 'auto_encode_cmd', 'topic'), + ) + } + elsif ($_[0] eq 'part') { + (weechat::hook_command_run('/part', 'auto_encode_cmd', 'wallchops'), + weechat::hook_command_run('/cycle', 'auto_encode_cmd', 'wallchops'), + ) + } + else { + () + } +} + +# /lma set + +# 0 network.* iso-user iso +# 0 network.#channel * utf8 --> iso-user always gets iso + +# 0 network.* iso-user iso +# 0 network.#channel + utf8 --> iso-user gets utf8 in #channel + +## load_config -- unconditionally try to pipe config file to /lma set +sub load_config { + weechat::mkdir_home('', 0755); + if (-e $CFG_FILE_NAME) { + open my $lfh, '<:utf8', $CFG_FILE_NAME || die $!; + while (<$lfh>) { + chomp; + lma_set('conf', $., split ' ', $_) + } + } + weechat::WEECHAT_RC_OK +} + +## save_config -- unconditionally try to save config +sub save_config { + weechat::mkdir_home('', 0755); + open my $sfh, '>:utf8', $CFG_FILE_NAME || die $!; + local $, = ' '; local $\ = "\n"; + for (@CFG_TABLE) { + print $sfh @{$_}{qw(time buf nick)}, @{$_->{charsets}}; + } + for (@ENCODE_TABLE) { + print $sfh '-out', $_->{buf}, @{$_->{pat}}, $_->{charset}; + } + weechat::WEECHAT_RC_OK +} + +## display_time -- pretty print time +## $now - current time +## $time - time to display +## returns s/m/h or HH:MM or mm/dd +sub display_time { + my ($now, $time) = @_; + my $d = $now - $time; + if ($d < 0) { + "+" + } + elsif ($d < 60) { + "-${d}s" + } + elsif ($d < 60 * 60) { + "-@{[int($d/60)]}m" + } + elsif ($d < 60 * 60 * 24) { + my @lt = localtime $time; + sprintf '%02d:%02d', $lt[2], $lt[1] + } + elsif ($d < 31_556_926) { + my @lt = localtime $time; + sprintf '%3s%2d', ucfirst $mon[$lt[4]], $lt[3] + } + else { + '-' + } +} + +## lma_list -- list decode configuration +## () - forwarded command handler +sub lma_list { + if (@_ > 2) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]} list\" command: $_[2]"); + return weechat::WEECHAT_RC_OK + } + my %lengths; + my $now = time; + my %header = ( time => (sprintf '%*s', (length $now), 'ts'), buf => 'buf', nick => 'nick', charsets => ['charsets']); + for my $ent (\%header, @CFG_TABLE) { + for (qw(time buf nick)) { + my $len = length $ent->{$_}; + $lengths{$_} = $len unless ($lengths{$_}//0) >= $len + } + my $cs_len = length join ' ', @{$ent->{charsets}}; + $lengths{charsets} = $cs_len unless ($lengths{charsets}//0) >= $cs_len; + } + my $hdr = sprintf '%*s(%*s)%*s %*s %*s', -$lengths{time}, $header{time}, 5, 'when', (map { -$lengths{$_}, $header{$_} } qw(buf nick)), -$lengths{charsets}, @{$header{charsets}}; + weechat::print('', $hdr); + weechat::print('', '-'x(length $hdr)); + for my $ent (@CFG_TABLE) { + weechat::print('', sprintf '%*s %*s %*s %*s'.(' %s'x@{$ent->{charsets}}), + $lengths{time}, $ent->{time}, 5, display_time($now, $ent->{time}), (map { -$lengths{$_}, $ent->{$_} } qw(buf nick)), @{$ent->{charsets}}); + } + if (@CFG_TABLE && @ENCODE_TABLE) { + weechat::print('', '-'x(length $hdr)); + } + + return weechat::WEECHAT_RC_OK unless @ENCODE_TABLE; + + my %enc_lengths; + my %enc_header = (buf => 'buf', pat => ['pattern'], charset => 'charset'); + for my $ent (\%enc_header, @ENCODE_TABLE) { + for (qw(buf charset)) { + my $len = length $ent->{$_}; + $enc_lengths{$_} = $len unless ($enc_lengths{$_}//0) >= $len + } + my $pat_len = length join ' ', @{$ent->{pat}}; + $enc_lengths{pat} = $pat_len unless ($enc_lengths{pat}//0) >= $pat_len; + } + my $enc_hdr = sprintf '%*s %*s %*s %*s', -$lengths{time}-6, 'output encodings', -$enc_lengths{buf}, $enc_header{buf}, -$enc_lengths{pat}, @{$enc_header{pat}}, -$enc_lengths{charset}, $enc_header{charset}; + weechat::print('', $enc_hdr); + weechat::print('', '-'x(length $enc_hdr)); + for my $ent (@ENCODE_TABLE) { + weechat::print('', sprintf '%*s %*s %*s %*s', + -$lengths{time}-6, '', -$enc_lengths{buf}, $ent->{buf}, -$enc_lengths{pat}, (join ' ', @{$ent->{pat}}), -$enc_lengths{charset}, $ent->{charset}); + } + weechat::WEECHAT_RC_OK +} + +## rel_time -- replace m/h/d postfix to negative time with no. of seconds +## $now - current time +## $_[1..$#_] - string to modify +sub rel_time { + my %td = (m => 60, h => 60 * 60, d => 60 * 60 * 24); + my $now = shift; + for (@_) { + my ($from, $to) = split /(?<])?(?:($mon_re)([0-2][1-9]|3[01]))?(?:(?:([01]?[0-9]|2[0-3]):([0-5][0-9]))(?::([0-5][0-9]))?)?$}{ + my ($pfx, $mon, $day, $hr, $min, $sec) = ($1//'', $mon{lc $2}//$lt[4], $3//$lt[3], $4//$lt[2], $5//$lt[1], $6//$lt[0]); + my $yr = $lt[5]; + my $day_back; + if ($mon > $lt[4] || ($mon == $lt[4] && $day > $lt[3])) { --$yr } + elsif ($mon == $lt[4] && $day == $lt[3] && + ($hr > $lt[2] || + ($hr == $lt[2] && ($min > $lt[1] || + ($min == $lt[1] && $sec > $lt[0]))))) { $day_back = 1 } + my $lt = timelocal($sec, $min, $hr, $day, $mon, $yr); + $lt -= 60 * 60 * 24 if $day_back; + $pfx.$lt + }ie || + s/(?{prio} <=> $a->{prio} || + ($a->{prio} && $b->prio ? ( + $b->{buf_len} <=> $a->{buf_len} || + $a->{_}{buf} cmp $b->{_}{buf} || + $b->{nick_len} <=> $a->{nick_len} || + $a->{_}{nick} cmp $b->{_}{nick}) : ( + $b->{nick_len} <=> $a->{nick_len} || + $a->{_}{nick} cmp $b->{_}{nick} || + $b->{buf_len} <=> $a->{buf_len} || + $a->{_}{buf} cmp $b->{_}{buf})) || + $b->{_}{time} <=> $a->{_}{time} + } + map { + +{ + buf_len => (2 * (length $_->{buf}) - 3 * ($_->{buf} =~ y/*//)), + nick_len => (2 * (length $_->{nick}) - 3 * ($_->{nick} =~ y/*//) - ($_->{nick} =~ /\+$/)), + prio => !!($_->{nick} =~ /\+$/), + buf_re => do { + my $buf = $_->{buf}; + wildcard_to_re($buf); + qr/^$buf$/i }, + nick_re => do { + my $nick = $_->{nick}; + $nick =~ s/\+$//; + $nick = '*' unless length $nick; + wildcard_to_re($nick); + qr/^$nick$/i }, + '_' => $_, + } + } @CFG_TABLE +} + +## lma_del_out -- delete output encoding +## $_[0] - 'int' if internal +## $buf - target specification +## $glob - set if last param starts with -g XXX +## @pat - match pattern +sub lma_del_out { + my (undef, $buf, $glob, @pat) = @_; + my $internal = $_[0] eq 'int'; + if ($glob) { + wildcard_to_re($buf, @pat); + } + else { + $_ = quotemeta for $buf, @pat; + } + my $pat_re = join '\s+', @pat; + my $num_cfg = @ENCODE_TABLE; + @ENCODE_TABLE = sort { $a->{buf} cmp $b->{buf} || (join ' ', @{$a->{pat}}) cmp (join ' ', @{$b->{pat}}) } + grep { + !( + $_->{buf} =~ /^\s*$buf\s*$/i && (join ' ', @{$_->{pat}}) =~ /^\s*$pat_re\s*$/i) + } + grep { length $_->{charset} } + @ENCODE_TABLE; + update_enc_table(); + weechat::print('', "Removed @{[$num_cfg-@ENCODE_TABLE]} entries from @{[SCRIPT_NAME]} list") unless $internal; + weechat::WEECHAT_RC_OK +} + +sub update_enc_table { + @ENCODE_TABLE2 = + sort { + $b->{buf_len} <=> $a->{buf_len} || + $a->{_}{buf} cmp $b->{_}{buf} || + $b->{pat_len} <=> $a->{pat_len} || + $a->{pat} cmp $b->{pat} + } + map { + my $pat = join ' ', @{$_->{pat}}; + +{ + pat => $pat, + buf_len => (2 * (length $_->{buf}) - 3 * ($_->{buf} =~ y/*//)), + pat_len => (2 * (length $pat) - 3 * ($pat =~ y/*//)), + buf_re => do { + my $buf = $_->{buf}; + wildcard_to_re($buf); + qr/^$buf$/i }, + pat_re => do { + my @pat = @{$_->{pat}}; + wildcard_to_re(@pat); + for (@pat) { + s/\.\*/\\S*/g unless $_ eq '.*'; # wasn't * + s/(?:\\S\*){2,}/.*/g; # reverse with ** + } + my $pat_re = join '\s+', @pat; + qr/^$pat_re$/i }, + '_' => $_, + } + } @ENCODE_TABLE +} + +## lma_set_out -- modify output encoding +## $_[0] - 'conf' if called from config +## $cs - charset +## $buf - target specification +## @pat - match pattern +sub lma_set_out { + my (undef, $cs, $buf, @pat) = @_; + my $conf = ($_[0]//'') eq 'conf'; + $cs//=''; + lma_del('int', undef, '-out', $buf, @pat); + push @ENCODE_TABLE, +{ buf => $buf, pat => \@pat, charset => $cs }; + my $msg = length $cs ? 'added' : 'removed'; + weechat::print('', join ' ', "$msg:", '-out', $buf, @pat, $cs) unless $conf; + + @ENCODE_TABLE = sort { $a->{buf} cmp $b->{buf} || (join ' ', @{$a->{pat}}) cmp (join ' ', @{$b->{pat}}) } + grep { length $_->{charset} } + @ENCODE_TABLE; + update_enc_table(); + weechat::WEECHAT_RC_OK +} + +## lma_set -- add or modify a rule entry +## () - forwarded command handler +## $_[0] - 'conf' if called from config load +## $time - timestamp +## $buf - buffer +## $nick - nick +## @charsets - list of charsets to try in order +sub lma_set { + my (undef, undef, $time, $buf, $nick, @charsets) = @_; + my $conf = ($_[0]//'') eq 'conf'; + my $conf_err = ($conf ? ", @{[SCRIPT_NAME]}.conf line $_[1]" : ''); + unless (defined $nick) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."@{[SCRIPT_NAME]}: too few arguments for \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK + } + my $now = time; + rel_time($now, $time); + my ($out_p, $recode_p); + if (lc $time eq '-out') { + $out_p = 1; + } + elsif ($time !~ /^-?\d+$/) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: incorrect number: $time in \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK + } + else { + $recode_p = 1; + $time += $now unless $time > 0; + } + + my @out_pattern; + if ($out_p) { + my $cs = pop @charsets; + @out_pattern = ($nick, @charsets); + @charsets = $cs//(); + } + else { + my $nick_p = $nick; + $nick_p =~ s/\+$//; + $nick_p = '*' unless length $nick_p; + @out_pattern = (($nick_p ne '*' ? $nick_p.Nlib::fu8on(weechat::config_string(weechat::config_get('weechat.completion.nick_completer'))) : ()), '*'); + } + my ($out_next, $out_charset); + my %enc_seen; + @charsets = grep { defined } + map { + if (!$out_p && lc $_ eq '-out') { + if (defined $out_next) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: multiple -out flags in \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK; + } + elsif (grep { $_->{buf} eq $buf && $_->{nick} eq $nick && $_->{time} > $time } @CFG_TABLE) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: -out flag not allowed for recodes in the past in \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK; + + } + $out_next = 1; + undef + } + else { + my $partial_decode; + if ($_ ne 'x') { + $partial_decode = s/!$//; + my $dec = Encode::find_encoding($_); + unless (defined $dec) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown encoding: $_ in \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK; + } + $_ = $dec->name; + $DEC{$_} //= $dec; + } + $out_charset = $_ if $out_p || $out_next; + $out_next = 0 if $out_next; + $partial_decode and $_ .= '!'; + $enc_seen{$_}++ ? undef : $_ + } + } @charsets; + if ($out_next) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: -out flag without encoding in \"@{[CMD_NAME]} set\" command$conf_err"); + return weechat::WEECHAT_RC_OK; + } + elsif ($out_p) { # only setting out charset, not decode table + return lma_set_out($_[0], $out_charset, $buf, @out_pattern); + } + lma_del('int', undef, $time, $buf, $nick); + my (@ent) = sort { $b->{time} <=> $a->{time} } grep { $_->{buf} eq $buf && $_->{nick} eq $nick } @CFG_TABLE; + my ($ent_before) = grep { $_->{time} < $time } @ent; + my ($ent_after) = grep { $_->{time} > $time } reverse @ent; + if ($ent_before && (join ' ', @{$ent_before->{charsets}}) eq (join ' ', @charsets)) { + lma_print_fmt($now, 'already existing', @{$ent_before}{qw(time buf nick)}, @{$ent_before->{charsets}}) unless $conf; + return weechat::WEECHAT_RC_OK + } + my $msg = 'added'; + if ($ent_after && (join ' ', @{$ent_after->{charsets}}) eq (join ' ', @charsets)) { + lma_del('int', undef, @{$ent_after}{qw(time buf nick)}); + $msg = 'moved'; + } + $msg = 'removed' unless @charsets; + + push @CFG_TABLE, +{ time => $time, buf => $buf, nick => $nick, charsets => \@charsets }; + lma_print_fmt($now, $msg, $time, $buf, $nick, @charsets) unless $conf; + + @CFG_TABLE = sort { $a->{buf} cmp $b->{buf} || $a->{nick} cmp $b->{nick} || $a->{time} <=> $b->{time} } + grep { @{$_->{charsets}} } + @CFG_TABLE; + if ($out_charset) { + lma_set_out($_[0], $out_charset, $buf, @out_pattern); + } + update_table2(); + update_all_lines() unless $conf; + weechat::WEECHAT_RC_OK +} + +# /lma del >time * * + +## wildcard_to_re -- convert * to .* and quotemeta everything else +## @_ - list of strings to modify (inplace) +sub wildcard_to_re { + for (@_) { + $_ = join '', map { + if ($_ eq '*') { '.*' } + else { + my $s = $_; + $s =~ s/\\([*\\])/$1/g; + quotemeta $s + } + } split /((? 5 && $_[-1] =~ /^-g/i ? pop : undef), @_[4..$#_]); + } + elsif (defined $invalid) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."@{[SCRIPT_NAME]}: too many arguments for \"@{[CMD_NAME]} del\" command"); + return weechat::WEECHAT_RC_OK + } + my $globs = defined $glob; + if ($globs && $glob !~ /^-g/i) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]} del\" command: $glob"); + return weechat::WEECHAT_RC_OK + } + my $now = time; + rel_time($now, $time) unless $internal; + if ($time !~ /^(?:[><]?-?\d+|[*]|-?\d+--?\d+)$/) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: incorrect number: $time in \"@{[CMD_NAME]} set\" command"); + return weechat::WEECHAT_RC_OK + } + my ($time_gt, $time_lt, $time_all, $time_range, $time_from, $time_to); + if ($time =~ s/^>//) { + $time_gt = 1 + } + elsif ($time =~ s/^ 0; + } + if ($globs) { + wildcard_to_re($buf, $nick); + } + else { + $_ = quotemeta for $buf, $nick; + } + my $num_cfg = @CFG_TABLE; + @CFG_TABLE = sort { $a->{buf} cmp $b->{buf} || $a->{nick} cmp $b->{nick} || $a->{time} <=> $b->{time} } + grep { + !( + ($time_all || + ($time_gt && $_->{time} >= $time) || + ($time_lt && $_->{time} <= $time) || + ($time_range && $_->{time} >= $time_from && $_->{time} <= $time_to) || + $_->{time} == $time) && + $_->{buf} =~ /^\s*$buf\s*$/i && $_->{nick} =~ /^\s*$nick\s*$/i) + } + grep { @{$_->{charsets}} } + @CFG_TABLE; + update_table2(); + weechat::print('', "Removed @{[$num_cfg-@CFG_TABLE]} entries from @{[SCRIPT_NAME]} list") unless $internal; + update_all_lines() unless $internal; + weechat::WEECHAT_RC_OK +} + +## lma_wee_save -- handle weechat /save or /reload +## () - command_run handler +## $_[0] - forward to which command +## $_[1] - buffer pointer +## $_[2] - command +sub lma_wee_save { + if ($_[2] =~ s/\s+luanma(?:\s+|$)/ /i) { + weechat::command($_[1], $_[2]) unless $_[2] =~ /\/$_[0]\s*$/i; + { no strict 'refs'; &{"lma_$_[0]"}(); } + weechat::WEECHAT_RC_OK_EAT + } + elsif ($_[2] =~ /\/$_[0]\s*$/i) { + weechat::command($_[1], $_[2]); + { no strict 'refs'; &{"lma_$_[0]"}(); } + weechat::WEECHAT_RC_OK_EAT + } + else { + weechat::WEECHAT_RC_OK + } +} + +## lma_save -- command handler to save config +## () - command handler +sub lma_save { + if (@_ > 2) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]} save\" command: $_[2]"); + return weechat::WEECHAT_RC_OK + } + save_config(); + weechat::print('', "Options saved to @{[SCRIPT_NAME]}.conf"); + weechat::WEECHAT_RC_OK +} + +## lma_reload -- reload config file +## () - command handler +sub lma_reload { + if (@_ > 2) { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]} reload\" command: $_[2]"); + return weechat::WEECHAT_RC_OK + } + @CFG_TABLE = @CFG_TABLE_2 = (); + load_config(); + update_all_lines(); # load_config doesn't do this for us + weechat::print('', "Options reloaded from @{[SCRIPT_NAME]}.conf"); + weechat::WEECHAT_RC_OK +} + +## lma_forget -- forget everything about messages, forget all raw and all esc messages +## () - forwarded command handler +sub lma_forget { + unless (@_ == 3 && lc $_[2] eq '-yes') { + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]} forget\" command"); + return weechat::WEECHAT_RC_OK + } + %$_ = () for @STO; + weechat::print('', 'forgotten'); + weechat::WEECHAT_RC_OK +} + +## lma_list_rules -- list internal rules and pointers (for debug and /debug tags) +## () - command handler +sub lma_list_rules { + my $now = time; + for (@CFG_TABLE_2) { + lma_print_fmt($now, (sprintf '0x%x', $_), @{$_->{_}}{qw(time buf nick)}, @{$_->{_}{charsets}}); + } + for (@ENCODE_TABLE2) { + weechat::print('', join ' ', ' 'x10, '-out', $_->{_}{buf}, @{$_->{_}{pat}}, $_->{_}{charset}); + } + weechat::WEECHAT_RC_OK +} + +## lma_cmd -- main command handler and dispatcher +## () - command handler +## $_[2] - arguments +sub lma_cmd { + Encode::_utf8_on($_[2]); + my @args = split ' ', $_[2]; + + my %disp = ( + set => \&lma_set, + add => \&lma_set, + list => \&lma_list, + save => \&lma_save, + reload => \&lma_reload, + del => \&lma_del, +## + forget => \&lma_forget, + list_rules => \&lma_list_rules, + gc => \&gc_lines, + ); + + @args = 'list' unless @args; + my $cmd = lc $args[0]; + + return $disp{$cmd}(@_[0..1], @args[1..$#args]) + if exists $disp{$cmd}; + + weechat::print('', Nlib::fu8on(weechat::prefix('error'))."Error: unknown option for \"@{[CMD_NAME]}\" command: $args[0]"); + return weechat::WEECHAT_RC_OK; +} + +sub sew_and_back { + my $msg = join ' ', " [@{[SCRIPT_NAME]}]", @_; + print STDERR $msg, "\b"x length $msg; +} + +## for_all_lines -- do something for all lines +## $_[0] - sub routine +sub for_all_lines(&) { +AO: for (my @buffers = Nlib::hdh('gui_buffers', 'buffer'); + $buffers[0]; + @buffers = Nlib::hdh(@buffers, '!var_next')) { + for (my @lines = Nlib::hdh(@buffers, 'own_lines', 'first_line'); + $lines[0]; + @lines = Nlib::hdh(@lines, '!var_next')) { + my $lp = oct $lines[0]; + $_[0]($lp, @lines); + } + } +} + +## FAnext -- next for_all_lines +sub FAnext() { + no warnings 'exiting'; + next +} + +## FAlast -- last for_all_lines +sub FAlast() { + no warnings 'exiting'; + last AO +} + +## async_reread_lines -- reread lines asynchronously +## () - timer handler +sub async_reread_lines { + sew_and_back('PARSING LINES'); + my $i = $ASYNC_PARSE; + local $GC_LIMIT; + for_all_lines { + my ($lp, @lines) = @_; + FAnext if exists $ASYNC_BUF{$lp}; + line_sig(undef, undef, @lines); + FAlast unless --$i; + }; + if ($i) { # finished, still $i left + weechat::unhook($ASYNC_TIMER); + $ASYNC_TIMER = undef; + %ASYNC_BUF = (); + } + weechat::command('', '/wait 200ms /window refresh'); + weechat::WEECHAT_RC_OK +} + +## reread_lines -- pipe all lines in weechat through line_sig (used on load) +sub reread_lines { + sew_and_back('PARSING LINES'); + my $i = 1; + local $GC_LIMIT; + for_all_lines { + my (undef, @lines) = @_; + sew_and_back('PARSING LINES', $i) unless ++$i % $PARSE_STATS; + line_sig(undef, undef, @lines) + }; + weechat::command('', '/window refresh'); +} + +## update_all_lines -- loop over all lines in weechat and apply new ruleset +sub update_all_lines { + if ($ASYNC_TIMER && $ASYNC_TIMER == 1) { # ondemand parser + delete @ASYNC_BUF{keys %BYTE_MSGS}; + ondemand_buffers(); + } + else { + sew_and_back('PARSING LINES'); + for_all_lines { + my $lp = shift; + apply_recode($lp) + if exists $BYTE_MSGS{$lp}; + }; + weechat::command('', '/window refresh'); + } +} + +# buffer lines last_line prev_line|data +# window scroll buffer +# window scroll start_line next_line|data +# window win_chat_height + +## ondemand_window -- signal handler that gets called on window +## $_[2] - window that changed +sub ondemand_window { + my @window = Nlib::hdh($_[2], 'window'); + my @scroll = Nlib::hdh(@window, 'scroll'); + my @buffer = Nlib::hdh(@scroll, 'buffer'); + my $dir; + my @lines = Nlib::hdh(@scroll, 'start_line'); + if ($lines[0]) { + $dir = '!var_next'; + } + else { + @lines = Nlib::hdh(@scroll, 'buffer', 'lines', 'last_line'); + $dir = '!var_prev'; + } + my $max = Nlib::hdh(@window, 'win_chat_height'); # rough approx. of lines that need processing + for (; + $lines[0]; + @lines = Nlib::hdh(@lines, $dir)) { + next unless Nlib::hdh(@lines, 'data', 'displayed'); + my $lp = oct $lines[0]; + if (exists $BYTE_MSGS{$lp} && !exists $ASYNC_BUF{$lp}) { + apply_recode($lp); + $ASYNC_BUF{$lp} = undef; + } + elsif (!exists $ASYNC_BUF{$lp}) { + line_sig(undef, undef, @lines); + } + last unless --$max; + } + weechat::WEECHAT_RC_OK +} + +## ondemand_buffers -- signal handler that gets called on all buffers +## $_[2] - buffer that changed, or all windows if undef +sub ondemand_buffers { + for (my @windows = Nlib::hdh('gui_windows', 'window'); + $windows[0]; + @windows = Nlib::hdh(@windows, '!var_next')) { + my @buffer = Nlib::hdh(@windows, 'scroll', 'buffer'); + next if defined $_[2] && $buffer[0] ne $_[2]; + ondemand_window(undef, undef, $windows[0]); + } + weechat::WEECHAT_RC_OK +} + +## ondemand_commands_hook -- redraw buffers after certain command +## () - command_run handler +## $_[1] - buffer +## $_[2] - command +sub ondemand_commands_hook { + weechat::command($_[1], $_[2]); + ondemand_buffers(); + weechat::WEECHAT_RC_OK_EAT +} + +## parse_ondemand_init -- initialize on-demand parser +sub parse_ondemand_init { + Nlib::hook_dynamic(signal => buffer_lines_hidden => 'ondemand_buffers', ''); #called for all affected buffers? + Nlib::hook_dynamic(signal => buffer_switch => 'ondemand_buffers', ''); #buffer switched to + Nlib::hook_dynamic(signal => window_scrolled => 'ondemand_window', ''); # + Nlib::hook_dynamic(signal => window_zoomed => 'ondemand_window', ''); + Nlib::hook_dynamic(command_run => "/window $_" => 'ondemand_commands_hook', '') + for qw(split* resize* balance merge* refresh); + ondemand_buffers(); +} + +## parse_ondemand_deinit -- stop on-demand parser +sub parse_ondemand_deinit { + Nlib::unhook_dynamic("/window $_" => 'ondemand_commands_hook') + for qw(split* resize* balance merge* refresh); + Nlib::unhook_dynamic(window_zoomed => 'ondemand_window'); + Nlib::unhook_dynamic(window_scrolled => 'ondemand_window'); + Nlib::unhook_dynamic(buffer_switch => 'ondemand_buffers'); + Nlib::unhook_dynamic(buffer_lines_hidden => 'ondemand_buffers'); + @ASYNC_BUF{keys %BYTE_MSGS} = (); +} + +## gc_lines -- remove raw lines from cache that are no longer valid in weechat +## () - can be forwarded command handler +## $_[0] - quiet if 'int' +sub gc_lines { + my %lines_seen; + @lines_seen{keys %BYTE_MSGS} = (); + for_all_lines { + my $lp = shift; + delete $lines_seen{$lp}; + }; + delete @{$_}{keys %lines_seen} for @STO; + weechat::print('', "gc'd @{[scalar keys %lines_seen]} lps") unless $_[0] eq 'int'; + weechat::WEECHAT_RC_OK +} + +## restore_lines -- put back all lines to their raw form (before unloading) +sub restore_lines { + sew_and_back('PARSING LINES'); + local (@CFG_TABLE, @CFG_TABLE_2); + for_all_lines { + my ($lp, @lines) = @_; + if (exists $BYTE_MSGS{$lp}) { + apply_recode($lp); + } + elsif (exists $ESC_MSG{$lp}) { + my @line_data = Nlib::hdh(@lines, 'data'); + my $s = Nlib::hdh(@line_data, 'message'); + $s =~ s/\020/\02010\020/g; + Nlib::hdh(@line_data, +{ message => $s }); + } + }; + weechat::command('', '/window refresh'); +} + +## default_options -- set up default option values on start and when unset +## () - config handler if @_ is set +sub default_options { + my %defaults = ( + tags => 'notice privmsg topic 332', + parser => 'ondemand', # async, full + encode_warn => 'on', + ); + for (keys %defaults) { + weechat::config_set_plugin($_, $defaults{$_}) + unless weechat::config_is_set_plugin($_); + } + @nags = split ' ', lc weechat::config_get_plugin('tags'); + $nag_tag = '^' .(join '|', map { quotemeta } + map { "irc_$_" } + sort { length $b <=> length $a } + @nags). '$'; + my %new_nag_modifiers; + for (@nags) { + if (exists $nag_modifiers{$_}) { + $new_nag_modifiers{$_} = delete $nag_modifiers{$_}; + } + else { + $new_nag_modifiers{$_} = [ + weechat::hook_modifier("irc_in_$_", 'irc_in_mod', ''), + weechat::hook_modifier("irc_out_$_", 'irc_out_mod', ''), + hook_encode_commands($_), + ]; + } + } + for (keys %nag_modifiers) { + weechat::unhook($_) for @{delete $nag_modifiers{$_}}; + } + %nag_modifiers = %new_nag_modifiers; + my $last_parser = defined $ASYNC_TIMER ? $ASYNC_TIMER ? $ASYNC_TIMER == 1 ? 'ondemand' + : 'async_in_progress' + : 'loading' + : 'full_or_finished'; + my $new_parser = lc weechat::config_get_plugin('parser'); + if ($last_parser eq 'async_in_progress' && $new_parser ne 'async') { + weechat::unhook($ASYNC_TIMER); + } + elsif ($last_parser eq 'full_or_finished' && $new_parser eq 'ondemand') { + for_all_lines { + my $lp = shift; + $ASYNC_BUF{$lp} = undef; + }; + } + elsif ($last_parser eq 'ondemand' && $new_parser ne 'ondemand') { + parse_ondemand_deinit(); + } + if ($new_parser eq 'ondemand') { + unless ($last_parser eq 'ondemand') { + $ASYNC_TIMER = 1; + parse_ondemand_init(); + } + } + elsif ($new_parser eq 'async') { + unless ($last_parser eq 'async_in_progress' || $last_parser eq 'full_or_finished') { + $ASYNC_TIMER = weechat::hook_timer(100, 0, 0, 'async_reread_lines', ''); + } + } + else { + if ($last_parser ne 'full_or_finished') { + $ASYNC_TIMER = undef; + %ASYNC_BUF = (); + reread_lines(); + } + } + weechat::WEECHAT_RC_OK +} + +sub init_luanma { + $GC_COUNT = 0; + load_config(); + $DEC{utf8} = Encode::find_encoding('utf8'); + $ASYNC_TIMER = 0; + default_options(); + my $sf = SCRIPT_FILE; + for (Nlib::get_settings_from_pod($sf)) { + weechat::config_set_desc_plugin($_, Nlib::get_desc_from_pod($sf, $_)); + } + weechat::WEECHAT_RC_OK +} + +sub stop_luanma { + lma_save() + if weechat::config_boolean(weechat::config_get('weechat.plugin.save_config_on_unload')); + restore_lines(); + weechat::WEECHAT_RC_OK +} diff -Nru weechat-scripts-20130123/perl/mass_hl_blocker.pl weechat-scripts-20131007/perl/mass_hl_blocker.pl --- weechat-scripts-20130123/perl/mass_hl_blocker.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/mass_hl_blocker.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,41 @@ +# Mass highlight blocker for WeeChat by arza , distributed freely and without any warranty, licensed under GPL3 + +weechat::register('mass_hl_blocker', 'arza ', '0.1', 'GPL3', 'Block mass highlights', '', ''); + +my $version=weechat::info_get('version_number', '') || 0; + +my $limit=5; + +if(weechat::config_is_set_plugin('limit')){ $limit=weechat::config_get_plugin('limit'); } +else{ weechat::config_set_plugin('limit', $limit); } + +if($version>=0x00030500){ weechat::config_set_desc_plugin('limit', 'minimum amount of nicks in line to disable highlight (default: 5)'); } + +weechat::hook_config('plugins.var.perl.mass_highlight_block.limit', 'set_limit', ''); +weechat::hook_modifier('2000|weechat_print', 'block', ''); + +sub block { my $message=$_[3]; + + $_[2]=~/(\S+);(\S+)\.(\S+);(\S+)/ || return $message; + my ($plugin, $server, $channel, $tags) = ($1, $2, $3, $4); + index($message, weechat::info_get('irc_nick', $server)) != -1 && index($tags, 'notify_message') != -1 && index($tags, 'no_highlight') == -1 || return $message; + + my $count=0; + foreach my $word (split(' ', $message)){ + my $infolist=weechat::infolist_get('irc_nick', '', "$server,$channel,$word"); + if($infolist){ $count++; } + weechat::infolist_free($infolist); + } + + if($count>=$limit){ + weechat::print_date_tags(weechat::buffer_search($plugin, "$server.$channel"), 0, "$tags,no_highlight", $message); + return ''; + } + + return $message; +} + +sub set_limit { + $limit=$_[2]; + return weechat::WEECHAT_RC_OK; +} diff -Nru weechat-scripts-20130123/perl/menu.pl weechat-scripts-20131007/perl/menu.pl --- weechat-scripts-20130123/perl/menu.pl 2013-01-23 19:00:25.000000000 +0000 +++ weechat-scripts-20131007/perl/menu.pl 2013-10-07 12:14:56.000000000 +0000 @@ -14,12 +14,18 @@ =head1 SYNOPSIS +=begin comment + first, copy the file to your F<.weechat/perl> directory. Then you can type /perl load menu.pl -in weechat to load the script. Use +in weechat to load the script. + +=end comment + +Use /menu @@ -65,9 +71,8 @@ to close any menu, type Ctrl+X on your keyboard. for mouse support, this script will listen to mouse input -signals. If your WeeChat does not have builtin cursor and mouse -support, another script is needed to supply these signals, such as -F which can be found in the same place as this script. +signals. You need WeeChat with builtin cursor and mouse +support. =head2 Nick menu @@ -91,19 +96,6 @@ global key bindings, so you will not be able to navigate the menu in this case. -=item * - -unfortunately, WeeChat scrolls back the nicklist whenever a bar is -hidden or shown. Some hacks are in this script to scroll it back to -where it was before, but only when you clicked on the nicklist, not -when interacting with the main menu. - -=item * - -to scroll the nicklist using the mouse, as well as switching windows -on mouse click, another script such as C might be -necessary. - =back =head1 TODO @@ -120,15 +112,7 @@ =item * interactive menu entries are lacking yet (like Join channel, Connect -to server) due to the missing implementation of the - - /menu interactive - -command. The entries are - - /menu interactive ask {Connect to server:} {Port:} /connect $0/$1 - /menu interactive ask {Join which channel?} /join $0 - /menu interactive yn {Are you sure?} /quit +to server) due to the missing implementation of a interactive command. =back @@ -159,6 +143,24 @@ if this is set to on, a submenu is not closed when the entry is confirmed but has to be closed manually using Ctrl+X. +=head2 active_help + +this setting is documented for completeness, it reflects if the help +bar is visible and can be toggled from within the menu with Ctrl+H. + +=head2 key_binding_hidden + +if set to on, the friendly reminder how to open the main menu (by +default: /menu to open menu) will be removed from view. useful for +those people bothered by it. + +=head2 main_menu_hidden + +if set to on, the main menu bar will be always hidden. useful if you +don't care about clicking on the main menu and want to save one line +on your screen (due to internal reasons, the setting +weechat.bar.main_menu.hidden does not work reliably, use this instead.) + =head1 MENU CONFIGURATION the whole menu is configurable through the file F or @@ -219,6 +221,21 @@ Refer to the three dynamic menus that ship with the sample config. +For usage with scripts, another form of dynamic menu is supported: + + /set menu.var.POPUP.1.command "%#info_hashtable% $1 % $0" + +The first part of command must be %#INFO_HASHTABLE_NAME% (see the +weechat api docs on weechat_hook_info_hashtable). + +The second and third part are passed on to the hashtable function in +the hashtable parameter. The returned hashtable must contain suitable +1.command/1.name pairs to be added into the menu. + +You can check the spell_menu script for an example of how to use this. + +=begin comment + =head1 FUNCTION DESCRIPTION for full pod documentation, filter this script with @@ -229,155 +246,480 @@ (s/^## (.*)/=back\n\n$1\n\n=cut\n/ and $o=0,1) or ($o and $o=0,1 and s/^sub /=back\n\n=cut\n\nsub /)' +=end comment + =cut use constant SCRIPT_NAME => 'menu'; -weechat::register(SCRIPT_NAME, 'Nei ', '0.7', 'GPL3', 'menu system', 'stop_menu', '') || return; -sub SCRIPT_FILE() { - my $infolistptr = weechat::infolist_get('perl_script', '', SCRIPT_NAME); - my $filename = weechat::infolist_string($infolistptr, 'filename') if weechat::infolist_next($infolistptr); - weechat::infolist_free($infolistptr); - return $filename unless @_; -} +our $VERSION = '0.9'; -{ -package Nlib; -# this is a weechat perl library -use strict; use warnings; no warnings 'redefine'; +#$$$ autoloaded{ +BEGIN { { package WeeP::Tie::hash_accessor; + use strict; use warnings; + use Carp; + use parent 'Tie::Hash'; + sub TIEHASH { + my $class = shift; + my (undef, $P) = @_; + bless +{ proxy => $P }, $class; + } + sub FETCH { + my $self = shift->_init; + my $key = shift; + croak "Attempt to access non-existent key '$key' in hdata '$${$self->{proxy}}{ns}[-1]'" + unless exists $self->{visible_keys}{$key}; + $self->{visible_keys}{$key}->() + } + ## method _s_o -- spawn new object or hdata object + ## $_s - name of class or hdata + ## $_o - object pointer + sub _s_o { + my $self = shift; + my ($name, $o) = @_; + return $o unless $o; + + my $nbase = (ref $self->{proxy})->new; + + my $name_ = $name . '_'; + my $O = eval { local $SIG{__DIE__}; $nbase->$name_ }; + if ($@) { + $O = $nbase->hdata_; + push @{ $$O->{ns} }, $name; + } + $O->_o($o) + } + sub _init { + my $self = shift; + return $self if $self->{visible_keys}; + + my $P = $self->{proxy}; + my $nbase = (ref $P)->new; + + $self->{hdata} //= $nbase->hdata_get($$P->{ns}[-1]); + $self->{visible_keys} = $self->{hdata} ? +{ + map { + my $key = $_; + my $array = $self->{hdata}->get_var_array_size_string('', $key); + my $type = $self->{hdata}->get_var_type_string($key); + my $name = $self->{hdata}->get_var_hdata($_) || 'void_ptr' if $type eq 'pointer'; + if ($array) { + my @array_accessor; + tie @array_accessor, 'WeeP::Tie::hdata_var_array', $self, $key, $array, $type, $name; + ( $key => sub { \@array_accessor } ) + } + elsif ($type eq 'pointer') { + ( $key => sub { $self->_s_o($name, + $self->{hdata}->$type($P, $key)); } ) + } + else { + ( $key => sub { $self->{hdata}->$type($P, $key) } ) + } + } split ',', $self->{hdata}->get_string('var_keys') + } + + : + + $$P->{ns}[-1] eq 'hdata' ? do { + my $name = 'void_ptr'; + for ($nbase->_infolist('hook', '', 'hdata')) { + if ($nbase->hdata_get($_->{hdata_name}) eq $P) { + $name = $_->{hdata_name}; + last + } + } + +{ + map { + my $key = $_; + ( $key => sub { $self->_s_o($name, $P->get_list($key)) } ) + } split ',', $P->get_string('list_keys') + } + } + + : + + +{}; + $self + } + sub STORE { + my $self = shift->_init; + my $key = shift; + my $value = shift; + if ($self->{hdata}->update('', +{ __update_allowed => $key })) { + $self->{hdata}->update($self->{proxy}, +{ $key => $value }) + } + else { + $self->{proxy}->set($key, $value); + } + } + sub EXISTS { + my $self = shift->_init; + my $key = shift; + exists $self->{visible_keys}{$key} + } + sub FIRSTKEY { + my $self = shift->_init; + my $a = keys %{$self->{visible_keys}}; # reset + $self->NEXTKEY(@_) + } + sub NEXTKEY { + my $self = shift->_init; + my $k = each %{$self->{visible_keys}}; + wantarray ? ($k, $self->FETCH($k)) : $k + } + sub SCALAR { + my $self = shift->_init; + scalar keys %{$self->{visible_keys}} + } +1} + +{ package WeeP::Tie::hdata_var_array; + use strict; use warnings; + use parent 'Tie::Array'; + sub TIEARRAY { + my $class = shift; + my ($parent, $key, $sizekey, $type, $name) = @_; + bless +{ + parent => $parent, + key => $key, + sizekey => $sizekey, + type => $type, + name => $name, + }, $class + } + sub FETCH { + my $self = shift; + my $idx = shift; + my $type = $self->{type}; + my $key = join '|', $idx, $self->{key}; + my $rv = $self->{parent}{hdata}->$type($self->{parent}{proxy}, $key); + if ($type eq 'pointer') { + $self->{parent}->_s_o($self->{name}, $rv); + } + else { + $rv + } + } + sub FETCHSIZE { + my $self = shift; + exists $self->{parent}{proxy}{ $self->{sizekey} } ? + $self->{parent}{proxy}{ $self->{sizekey} } : + $self->{parent}{hdata}->get_var_array_size($self->{parent}{proxy}, $self->{key}) + } + +1} + +{ package WeeP::Tie::hdata_list; + use strict; use warnings; + use Carp; + use parent 'Tie::Array'; + BEGIN { our $NEGATIVE_INDICES = 1 } + sub TIEARRAY { + my $class = shift; + my ($parent) = @_; + bless +{ + parent => $parent, + }, $class + } + sub FETCH { + my $self = shift; + my $idx = shift; + my $P = $self->{parent}{proxy}; + my $nbase = (ref $P)->new; + + if ($self->{parent}{hdata} //= $nbase->hdata_get($$P->{ns}[-1])) { + my $o = $self->{parent}{hdata}->move($P, $idx); + return $o unless $o; + my $O = (ref $P)->new; + $$O->{ns} = [ @{ $$P->{ns} } ]; + $O->_o($o) + } + else { + croak "Attempt to access non-existent hdata in '$${$P}{ns}[-1]'" + } + } + sub FETCHSIZE { 0 } +1} + +{ package Weechat; + use strict; use warnings; + use Carp; + use Hash::Util; + use Scalar::Util qw(weaken); + use overload ( + fallback => 1, + '""' => sub { + my $I = shift; + $$I->{o} // join '', ref $I, '::', join '_', @{ $$I->{ns} } + }, + '%{}' => sub { ${+shift}->{_hdata} }, + '@{}' => sub { ${+shift}->{_hdata_move} }, + ); + + my ($pkg, %TypeMap, %AdviceReturn, %AdviceCallback, %_object_table); + BEGIN { + $pkg = 'weechat::'; + %TypeMap = ( + b => 'buffer', + s => 'string', + c => 'config_option', + w => 'window', + i => 'infolist', + h => 'hdata', + C => 'WEECHAT', + F => 'config', # _file + S => 'config_section', + B => 'bar', + ); + Hash::Util::lock_hash(%TypeMap); + %AdviceReturn = ( + infolist_get => 'i', + hdata_get => 'h', + config_get => 'c', + current_window => 'w', + current_buffer => 'b', + buffer_new => 'b', + buffer_search => 'b', + buffer_search_main => 'b', + config_new => 'F', + config_new_section => 'S', + bar_search => 'B', + bar_new => 'B', + ); + Hash::Util::lock_hash(%AdviceReturn); + %AdviceCallback = ( + hook_command => '.....cd|xb.', + buffer_new => '.cdcd|xb.|xb', + ); + Hash::Util::lock_hash(%AdviceCallback); + } + + + sub AUTOLOAD { + our $AUTOLOAD; + return if '::DESTROY' eq substr $AUTOLOAD, -9; + + my $I = $_[0]; + if (!ref $I && $AUTOLOAD eq __PACKAGE__.'::new') { + my $O = bless \ +{ + ns => [], + o => undef, + _hdata => {}, + _hdata_move => [], + }, $I; + tie @{ $$O->{_hdata_move} }, 'WeeP::Tie::hdata_list', + tie %{ $$O->{_hdata} }, 'WeeP::Tie::hash_accessor', '__auto__', $O; + return $O + } + if (ref $I) { + my ($fn) = $AUTOLOAD =~ /::(.*)/; + if ($fn =~ s/_$//) { + my %MapType = reverse %TypeMap; + exists $MapType{$fn} || croak "Unknown namespace: $fn"; + return $I->ns($MapType{$fn}) + } + + unless (defined $$I->{o}) { shift } + my @ns = @{ $$I->{ns} }; + do { + my $n = join '_', @ns, $fn; + my $sub = $pkg . $n; + if (exists &$sub) { + if (exists $AdviceCallback{$n}) { + my ($mangle, @bless) = split /\|/, $AdviceCallback{$n}; + my $i = 0; + my @c; + for my $x (split //, $mangle) { + next if $x eq '.'; + if ($x eq 'c') { + push @c, length $_[$i] ? + splice @_, $i, 1, '::'.(ref $I).'::GenericCallback' : ''; + } + elsif ($x eq 'd') { + splice @_, $i, 1, join '|', shift @bless, shift @c, $_[$i]; + } + } + continue { + ++$i; + } + } + if (exists $AdviceReturn{$n}) { + no strict 'refs'; + return (ref $I)->new->na($AdviceReturn{$n} => &$sub); + } + goto &$sub; + } + } while pop @ns; + croak "Method \"$fn\" not found in namespace \"$pkg@{[ join '_', @{ $$I->{ns} } ]}\""; + } + croak "Invalid call to &$AUTOLOAD"; + } + + ## method na -- bless strings into namespace objects + ## $_[0] - namespace letter format string + ## @_[1..$#_] - arguments + ## returns arguments + sub na { + my $I = shift; + croak "Cannot call method na on an existing namespace ($pkg@{[ join '_', @{ $$I->{ns} } ]})" if @{$$I->{ns}}; + my @format = split '', +shift; + my $i = 0; + for my $e (@_) { + next if $format[$i] eq '.'; + $e = $I->ns($format[$i])->_o($e); + } + continue { + ++$i; + } + @format == 1 ? $_[0] : @_ > 1 ? @_ : return + } + + ## method ns -- get namespace handler + ## $f - namespace letter + ## returns handler + sub ns { + my $I = shift; + croak "Cannot call method ns on an existing namespace ($pkg@{[ join '_', @{ $$I->{ns} } ]})" if @{$$I->{ns}}; + my $f = shift; + exists $TypeMap{$f} || croak "Invalid format: $f"; + my $t = $TypeMap{$f}; + my $O = (ref $I)->new; + $$O->{ns} = [ split '_', $t ]; + $O + } + + ## mutator method _o -- set object address + ## returns the new object to be used + ## usage: $obj = $obj->_o($addr) + sub _o { + my $I = shift; + croak "Cannot call method _o on an existing object ($pkg@{[ join '_', @{ $$I->{ns} } ]}#@{[ $$I->{o} ]})" if $$I->{o}; + $$I->{o} = shift; + unless ($_object_table{$I}) { + $_object_table{$I} = $I; + weaken $_object_table{$I}; + } + $_object_table{$I} + } + + ## method _infolist -- copy weechat infolist content into perl hash + ## $infolist - name of the infolist in weechat [ONLY when called on base class] + ## $ptr - pointer argument (infolist dependend) [ONLY when called on base class or namespace] + ## @args - arguments to the infolist (list dependend) + ## $fields - string of ref type "fields" if only certain keys are needed (optional) + ## returns perl list with perl hashes for each infolist entry + sub _infolist { + my $I = shift; + my %i2htm = (i => 'integer', s => 'string', p => 'pointer', b => 'buffer', t => 'time'); + local *weechat::infolist_buffer = sub { '(not implemented)' }; weechat::infolist_buffer(); + + my $name = @{$$I->{ns}} ? + ($$I->{ns}[0] eq 'hdata' ? $$I->{ns}[-1] : join '_', @{ $$I->{ns} }) + : shift; + my $ptr = $$I->{o} ? $I : shift; + $ptr ||= ""; + + my $fields = ref $_[-1] eq 'fields' ? ${ +pop } : undef; + my $infptr = (ref $I)->new->infolist_get($name, $ptr, join ',', @_); + my @infolist; + while ($infptr->next) { + my @fields = map { + my ($t, $v) = split ':', $_, 2; + bless \$v, $i2htm{$t}; + } split ',', ($fields || $infptr->fields); + + push @infolist, +{ do { + my (%list, %local, @local); + map { + my $fn = ref $_; + my $r = $infptr->$fn($$_); + if ($$_ =~ /^localvar_name_(\d+)$/) { + $local[$1] = $r; + () + } + elsif ($$_ =~ /^(localvar)_value_(\d+)$/) { + $local{$local[$2]} = $r; + $1 => \%local + } + elsif ($$_ =~ /(.*?)((?:_\d+)+)$/) { + my ($key, $idx) = ($1, $2); + my @idx = split '_', $idx; shift @idx; + my $target = \$list{$key}; + for my $x (@idx) { + my $o = 1; + if ($key eq 'key' or $key eq 'key_command') { + $o = 0; + } + $target = \$$target->[$x-$o] + } + $$target = $r; + + $key => $list{$key} + } + else { + $$_ => $r + } + } @fields + } }; + } + $infptr->free; + !wantarray && @infolist ? ($$I->{o} && @infolist == 1) ? $infolist[0] : \@infolist : @infolist + } + + sub _prev { + shift->[-1] + } + sub _next { + shift->[1] + } + + sub _list_full { + my $I = shift; + my @list = $I; + my ($l, $r) = ($I->_prev, $I->_next); + while ($l || $r) { + if ($l) { + unshift @list, $l; + $l = $l->_prev; + } + if ($r) { + push @list, $r; + $r = $r->_next; + } + } + !wantarray && @list ? \@list : @list + } + + ## class method GenericCallback -- called for callback to do advisory typing + ## $_[0] - hopefully the user data :) + sub GenericCallback { + my ($bless, $fn, $args) = split /\|/, +shift, 3; + if ($bless =~ s/^x/./) { + unshift @_, $args; + __PACKAGE__->new->na($bless => @_); + $fn = join '::', '', (caller)[0], $fn; + goto &$fn; + } + } +1} + }; +#$$$ }autoloaded + +# define some abbreviations +use constant W => new Weechat; # weechat:: +use constant WC => W->WEECHAT_; # weechat::WEECHAT_ +use constant Wstr => W->string_; # weechat::string_ -## i2h -- copy weechat infolist content into perl hash -## $infolist - name of the infolist in weechat -## $ptr - pointer argument (infolist dependend) -## @args - arguments to the infolist (list dependend) -## $fields - string of ref type "fields" if only certain keys are needed (optional) -## returns perl list with perl hashes for each infolist entry -sub i2h { - my %i2htm = (i => 'integer', s => 'string', p => 'pointer', b => 'buffer', t => 'time'); - local *weechat::infolist_buffer = sub { '(not implemented)' }; - my ($infolist, $ptr, @args) = @_; - $ptr ||= ""; - my $fields = ref $args[-1] eq 'fields' ? ${ pop @args } : undef; - my $infptr = weechat::infolist_get($infolist, $ptr, do { local $" = ','; "@args" }); - my @infolist; - while (weechat::infolist_next($infptr)) { - my @fields = map { - my ($t, $v) = split ':', $_, 2; - bless \$v, $i2htm{$t}; - } - split ',', - ($fields || weechat::infolist_fields($infptr)); - push @infolist, +{ do { - my (%list, %local, @local); - map { - my $fn = 'weechat::infolist_'.ref $_; - my $r = do { no strict 'refs'; &$fn($infptr, $$_) }; - if ($$_ =~ /^localvar_name_(\d+)$/) { - $local[$1] = $r; - () - } - elsif ($$_ =~ /^(localvar)_value_(\d+)$/) { - $local{$local[$2]} = $r; - $1 => \%local - } - elsif ($$_ =~ /(.*?)((?:_\d+)+)$/) { - my ($key, $idx) = ($1, $2); - my @idx = split '_', $idx; shift @idx; - my $target = \$list{$key}; - for my $x (@idx) { - my $o = 1; - if ($key eq 'key' or $key eq 'key_command') { - $o = 0; - } - if ($x-$o < 0) { - local $" = '|'; - weechat::print('',"list error: $target/$$_/$key/$x/$idx/@idx(@_)"); - $o = 0; - } - $target = \$$target->[$x-$o] - } - $$target = $r; - - my $code = qq{ - local \$[=1; - \$list{"\Q$key\E"}$idx = \$r - }; - $key => $list{$key} - } - else { - $$_ => $r - } - } @fields - } }; - } - weechat::infolist_free($infptr); - !wantarray && @infolist ? \@infolist : @infolist +BEGIN { # import constants and functions into Nlib class + *Nlib::W = \&W; } -## hdh -- hdata helper -sub hdh { - if (@_ > 1 && $_[0] !~ /^0x/ && $_[0] !~ /^\d+$/) { - my $arg = shift; - unshift @_, weechat::hdata_get_list(weechat::hdata_get($_[0]), $arg); - } - while (@_ > 2) { - my ($arg, $name, $var) = splice @_, 0, 3; - my $hdata = weechat::hdata_get($name); - - $var =~ s/!(.*)/weechat::hdata_get_string($hdata, $1)/e; - (my $plain_var = $var) =~ s/^\d+\|//; - my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); - if ($type eq 'pointer') { - my $name = weechat::hdata_get_var_hdata($hdata, $var); - unshift @_, $name if $name; - } - - my $fn = "weechat::hdata_$type"; - unshift @_, do { no strict 'refs'; - &$fn($hdata, $arg, $var) }; - } - wantarray ? @_ : $_[0] -} - -## find_bar_window -- find the bar window where the coordinates belong to -## $row - row -## $col - column -## returns bar window infolist and bar infolist in a array ref if found -sub find_bar_window { - my ($row, $col) = @_; - - my $barwinptr; - my $bar_info; - for (i2h('bar_window')) { - return [ $_, $bar_info ] if - $row > $_->{'y'} && $row <= $_->{'y'}+$_->{'height'} && - $col > $_->{'x'} && $col <= $_->{'x'}+$_->{'width'} && - (($bar_info)=i2h('bar', $_->{'bar'})) && !$bar_info->{'hidden'}; - } +#$$$ autoloaded{ +BEGIN { { package Nlib; +# this is a weechat perl library +use strict; use warnings; -} +# to read the following docs, you can use "perldoc Nlib.pm" -## in_window -- check if given coordinates are in a window -## $row - row -## $col - column -## $wininfo - infolist of window to check -## returns true if in window -sub in_window { - my ($row, $col, $wininfo) = @_; - - # in window? - $row > $wininfo->{'y'} && - $row <= $wininfo->{'y'}+$wininfo->{'height'} && - $col > $wininfo->{'x'} && - $col <= $wininfo->{'x'}+$wininfo->{'width'} -} - -## has_true_value -- some constants for "true" -## $v - value string -## returns true if string looks like a true thing -sub has_true_value { - my $v = shift || ''; - $v =~ /^(?:on|yes|y|true|t|1)$/i -} ## hook_dynamic -- weechat::hook something and store hook reference ## $hook_call - hook type (e.g. modifier) @@ -416,276 +758,53 @@ die $@ if $@; } -## bar_filling -- get current filling according to position -## $bar_infos - info about bar (from find_bar_window) -## returns filling as an integer number -sub bar_filling { - my ($bar_infos) = @_; - ($bar_infos->[-1]{'position'} <= 1 ? $bar_infos->[-1]{'filling_top_bottom'} - : $bar_infos->[-1]{'filling_left_right'}) -} - -sub fu8on(@) { - Encode::_utf8_on($_) for @_; wantarray ? @_ : shift -} - -use Text::CharWidth; +use Pod::Select qw(); +use Pod::Simple::TextContent; -sub screen_length($) { - Text::CharWidth::mbswidth($_[0]) -} +## get_desc_from_pod -- return setting description from pod documentation +## $file - filename with pod +## $setting - name of setting +## returns description as text +sub get_desc_from_pod { + my $file = shift; + return unless -s $file; + my $setting = shift; -## bar_column_max_length -- get max item length for column based filling -## $bar_infos - info about bar (from find_bar_window) -## returns max item length -sub bar_column_max_length { - my ($bar_infos) = @_; - my @items; - for (@{ $bar_infos->[0]{'items_content'} }) { - push @items, split "\n", join "\n", @$_; - } - my $max_length = 0; - for (@items) { - my $item_length = screen_length fu8on weechat::string_remove_color($_, ''); - $max_length = $item_length if $max_length < $item_length; - } - $max_length; -} + open my $pod_sel, '>', \my $ss; + Pod::Select::podselect({ + -output => $pod_sel, + -sections => ["SETTINGS/$setting"]}, $file); -## find_bar_item_pos -- get position of an item in a bar structure -## $bar_infos - instance and general info about bar (from find_bar_window) -## $search - search pattern for item name -## returns (outer position, inner position, true if found) -sub find_bar_item_pos { - my ($bar_infos, $search) = @_; - my $item_pos_a = 0; - my $item_pos_b; - for (@{ $bar_infos->[-1]{'items_array'} }) { - $item_pos_b = 0; - for (@$_) { - return ($item_pos_a, $item_pos_b, 1) - if $_ =~ $search; - ++$item_pos_b; - } - ++$item_pos_a; - } - (undef, undef, undef) -} + my $pt = new Pod::Simple::TextContent; + $pt->output_string(\my $ss_f); + $pt->parse_string_document($ss); -## bar_line_wrap_horiz -- apply linebreak for horizontal bar filling -## $prefix_col_r - reference to column counter -## $prefix_y_r - reference to row counter -## $bar_infos - info about bar (from find_bar_window) -sub bar_line_wrap_horiz { - my ($prefix_col_r, $prefix_y_r, $bar_infos) = @_; - while ($$prefix_col_r > $bar_infos->[0]{'width'}) { - ++$$prefix_y_r; - $$prefix_col_r -= $bar_infos->[0]{'width'}; - } + my ($res) = $ss_f =~ /^\s*\Q$setting\E\s+(.*)\s*/; + $res } -## bar_lines_column_vert -- count lines in column layout -## $bar_infos - info about bar (from find_bar_window) -## returns lines needed for columns_horizontal layout -sub bar_lines_column_vert { - my ($bar_infos) = @_; - my @items; - for (@{ $bar_infos->[0]{'items_content'} }) { - push @items, split "\n", join "\n", @$_; - } - my $max_length = bar_column_max_length($bar_infos); - my $dummy_col = 1; - my $lines = 1; - for (@items) { - if ($dummy_col+$max_length > 1+$bar_infos->[0]{'width'}) { - ++$lines; - $dummy_col = 1; - } - $dummy_col += 1+$max_length; - } - $lines; -} - -## bar_items_skip_to -- skip several bar items on search for subitem position -## $bar_infos - info about bar (from find_bar_window) -## $search - patter of item to skip to -## $col - pointer column -## $row - pointer row -sub bar_items_skip_to { - my ($bar_infos, $search, $col, $row) = @_; - $col += $bar_infos->[0]{'scroll_x'}; - $row += $bar_infos->[0]{'scroll_y'}; - my ($item_pos_a, $item_pos_b, $found) = - find_bar_item_pos($bar_infos, $search); - - return 'item position not found' unless $found; - - # extract items to skip - my $item_join = - (bar_filling($bar_infos) <= 1 ? '' : "\n"); - my @prefix; - for (my $i = 0; $i < $item_pos_a; ++$i) { - push @prefix, split "\n", join $item_join, @{ $bar_infos->[0]{'items_content'}[$i] }; - } - push @prefix, split "\n", join $item_join, @{ $bar_infos->[0]{'items_content'}[$item_pos_a] }[0..$item_pos_b-1] if $item_pos_b; - - # cursor - my $prefix_col = 1; - my $prefix_y = 1; - my $item_max_length; - my $col_vert_lines; - - # forward cursor - if (!bar_filling($bar_infos)) { - my $prefix = join ' ', @prefix; - $prefix_col += screen_length fu8on weechat::string_remove_color($prefix, ''); - ++$prefix_col if @prefix && !$item_pos_b; - bar_line_wrap_horiz(\($prefix_col, $prefix_y), $bar_infos); - } - elsif (bar_filling($bar_infos) == 1) { - $prefix_y += @prefix; - if ($item_pos_b) { - --$prefix_y; - $prefix_col += screen_length fu8on weechat::string_remove_color($prefix[-1], ''); - } - } - elsif (bar_filling($bar_infos) == 2) { - $item_max_length = bar_column_max_length($bar_infos); - for (@prefix) { - $prefix_col += 1+$item_max_length; - if ($prefix_col+$item_max_length > 1+$bar_infos->[0]{'width'}) { - ++$prefix_y; - $prefix_col = 1; - } - } - } - elsif (bar_filling($bar_infos) == 3) { - $item_max_length = bar_column_max_length($bar_infos); - $col_vert_lines = $bar_infos->[-1]{'position'} <= 1 ? bar_lines_column_vert($bar_infos) : $bar_infos->[0]{'height'}; - my $pfx_idx = 0; - for (@prefix) { - $prefix_y = 1+($pfx_idx % $col_vert_lines); - $prefix_col = 1+(1+$item_max_length)*(int($pfx_idx / $col_vert_lines)+1); - return 'in prefix' - if ($prefix_y == $row && $prefix_col > $col); - ++$pfx_idx; - } - $prefix_y = 1+(@prefix % $col_vert_lines); - $prefix_col = 1+(1+$item_max_length)*int(@prefix / $col_vert_lines); - } - - (undef, - $item_pos_a, $item_pos_b, - $prefix_col, $prefix_y, - (scalar @prefix), - $item_max_length, $col_vert_lines) -} - -## bar_item_get_subitem_at -- extract subitem from a bar item at given coords -## $bar_infos - info about bar -## $search - search pattern for item whose subitems to get -## $col - pointer column -## $row - pointer row -## returns error message, subitem index, subitem text -sub bar_item_get_subitem_at { - my ($bar_infos, $search, $col, $row) = @_; - - my ($error, - $item_pos_a, $item_pos_b, - $prefix_col, $prefix_y, - $prefix_cnt, - $item_max_length, $col_vert_lines) = - bar_items_skip_to($bar_infos, $search, $col, $row); - - $col += $bar_infos->[0]{'scroll_x'}; - $row += $bar_infos->[0]{'scroll_y'}; - - return $error if $error; - - return 'no viable position' - unless (($row == $prefix_y && $col >= $prefix_col) || $row > $prefix_y || bar_filling($bar_infos) >= 3); - - my @subitems = split "\n", $bar_infos->[0]{'items_content'}[$item_pos_a][$item_pos_b]; - my $idx = 0; - for (@subitems) { - my ($beg_col, $beg_y) = ($prefix_col, $prefix_y); - $prefix_col += screen_length fu8on weechat::string_remove_color($_, ''); - if (!bar_filling($bar_infos)) { - bar_line_wrap_horiz(\($prefix_col, $prefix_y), $bar_infos); - } - - return (undef, $idx, $_, [$beg_col, $col, $prefix_col, $beg_y, $row, $prefix_y]) - if (($prefix_col > $col && $row == $prefix_y) || ($row < $prefix_y && bar_filling($bar_infos) < 3)); - - ++$idx; - - if (!bar_filling($bar_infos)) { - ++$prefix_col; - return ('outside', $idx-1, $_) - if ($prefix_y == $row && $prefix_col > $col); - } - elsif (bar_filling($bar_infos) == 1) { - return ('outside', $idx-1, $_) - if ($prefix_y == $row && $col >= $prefix_col); - ++$prefix_y; - $prefix_col = 1; - } - elsif (bar_filling($bar_infos) == 2) { - $prefix_col += 1+$item_max_length-(($prefix_col-1)%($item_max_length+1)); - - return ('outside', $idx-1, $_) - if ($prefix_y == $row && $prefix_col > $col); - - if ($prefix_col+$item_max_length > 1+$bar_infos->[0]{'width'}) { - return ('outside item', $idx-1, $_) - if ($prefix_y == $row && $col >= $prefix_col); - - ++$prefix_y; - $prefix_col = 1; - } - } - elsif (bar_filling($bar_infos) == 3) { - $prefix_col += 1+$item_max_length-(($prefix_col-1)%($item_max_length+1)); - return ('outside', $idx-1, $_) - if ($prefix_y == $row && $prefix_col > $col); - $prefix_y = 1+(($idx+$prefix_cnt) % $col_vert_lines); - $prefix_col = 1+(1+$item_max_length)*int(($idx+$prefix_cnt) / $col_vert_lines); +## get_settings_from_pod -- retrieve all settings in settings section of pod +## $file - file with pod +## returns list of all settings +sub get_settings_from_pod { + my $file = shift; + return unless -s $file; - } - } - 'not found'; -} + open my $pod_sel, '>', \my $ss; + Pod::Select::podselect({ + -output => $pod_sel, + -sections => ["SETTINGS//!.+"]}, $file); -## bar_item_get_item_and_subitem_at -- gets item and subitem at position -## $bar_infos - info about bar -## $col - pointer column -## $row - pointer row -## returns generic item, error if outside subitem, index of subitem and text of subitem -sub bar_item_get_item_and_subitem_at { - my ($bar_infos, $col, $row) = @_; - my $item_pos_a = 0; - my $item_pos_b; - for (@{ $bar_infos->[-1]{'items_array'} }) { - $item_pos_b = 0; - for (@$_) { - my $g_item = "^\Q$_\E\$"; - my ($error, @rest) = - bar_item_get_subitem_at($bar_infos, $g_item, $col, $row); - return ($_, $error, @rest) - if (!defined $error || $error =~ /^outside/); - return () if $error eq 'no viable position'; - ++$item_pos_b; - } - ++$item_pos_a; - } - () + $ss =~ /^=head2\s+(.*)\s*$/mg } ## mangle_man_for_wee -- turn man output into weechat codes +## @_ - list of grotty lines that should be turned into weechat attributes +## returns modified lines and modifies lines in-place sub mangle_man_for_wee { for (@_) { - s/_\x08(.)/weechat::color('underline').$1.weechat::color('-underline')/ge; - s/(.)\x08\1/weechat::color('bold').$1.weechat::color('-bold')/ge; + s/_\x08(.)/W->color('underline').$1.W->color('-underline')/ge; + s/(.)\x08\1/W->color('bold').$1.W->color('-bold')/ge; } wantarray ? @_ : $_[0] } @@ -698,103 +817,115 @@ my $file = shift; my $name = shift; - if (my $obuf = weechat::buffer_search('perl', "man $name")) { + if (my $obuf = W->buffer_search('perl', "man $name")) { eval qq{ package $caller_package; weechat::buffer_close(\$obuf); }; } - my @wee_keys = Nlib::i2h('key'); + my @wee_keys = W->_infolist('key'); my @keys; - my $winptr = weechat::current_window(); - my ($wininfo) = Nlib::i2h('window', $winptr); - my $buf = weechat::buffer_new("man $name", '', '', '', ''); - return weechat::WEECHAT_RC_OK unless $buf; + my $win = W->current_window(); + my $buf = W->buffer_new("man $name", '', '', '', ''); + return WC->RC_OK unless $buf; + + my $width = $win->{win_chat_width}; + --$width if $win->{win_chat_width} < $win->{win_width} || ($win->{win_width_pct} < 100 && (grep { $_->{win_y} == $win->{win_y} } W->hdata_get('window')->{gui_windows}->_list_full)[-1]{win_x} > $win->{win_x}); + $width -= 2; # when prefix is shown - my $width = $wininfo->{'chat_width'}; - --$width if $wininfo->{'chat_width'} < $wininfo->{'width'} || ($wininfo->{'width_pct'} < 100 && (grep { $_->{'y'} == $wininfo->{'y'} } Nlib::i2h('window'))[-1]{'x'} > $wininfo->{'x'}); - - weechat::buffer_set($buf, 'time_for_each_line', 0); + $buf->{time_for_each_line} = 0; eval qq{ package $caller_package; weechat::buffer_set(\$buf, 'display', 'auto'); }; die $@ if $@; - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input history_previous' || - $_->{'command'} eq '/input history_global_previous' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input history_previous' || + $_->{command} eq '/input history_global_previous' } @wee_keys; @keys = 'meta2-A' unless @keys; - weechat::buffer_set($buf, "key_bind_$_", '/window scroll -1') for @keys; + $buf->set("key_bind_$_" => '/window scroll -1') for @keys; - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input history_next' || - $_->{'command'} eq '/input history_global_next' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input history_next' || + $_->{command} eq '/input history_global_next' } @wee_keys; @keys = 'meta2-B' unless @keys; - weechat::buffer_set($buf, "key_bind_$_", '/window scroll +1') for @keys; + $buf->set("key_bind_$_" => '/window scroll +1') for @keys; - weechat::buffer_set($buf, 'key_bind_ ', '/window page_down'); + $buf->set('key_bind_ ' => '/window page_down'); - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input delete_previous_char' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input delete_previous_char' } @wee_keys; @keys = ('ctrl-?', 'ctrl-H') unless @keys; - weechat::buffer_set($buf, "key_bind_$_", '/window page_up') for @keys; + $buf->set("key_bind_$_" => '/window page_up') for @keys; + + @keys = map { $_->{key} } + grep { $_->{command} eq '/input move_beginning_of_line' } @wee_keys; + push @keys, 'g'; + $buf->set("key_bind_$_" => '/window scroll_top') for @keys; - weechat::buffer_set($buf, 'key_bind_g', '/window scroll_top'); - weechat::buffer_set($buf, 'key_bind_G', '/window scroll_bottom'); + @keys = map { $_->{key} } + grep { $_->{command} eq '/input move_end_of_line' } @wee_keys; + push @keys, 'G'; + $buf->set("key_bind_$_" => '/window scroll_bottom') for @keys; - weechat::buffer_set($buf, 'key_bind_q', '/buffer close'); + $buf->set('key_bind_q' => '/buffer close'); - weechat::print($buf, " \t".mangle_man_for_wee($_)) + $buf->print(" \t".mangle_man_for_wee($_)) for `pod2man \Q$file\E 2>/dev/null | GROFF_NO_SGR=1 nroff -mandoc -rLL=${width}n -rLT=${width}n -Tutf8 2>/dev/null`; - weechat::command($buf, '/window scroll_top'); + $buf->command('/window scroll_top'); - unless (hdh($buf, 'buffer', 'lines', 'lines_count') > 0) { - weechat::print($buf, weechat::prefix('error').$_) - for "Unfortunately, your @{[weechat::color('underline')]}nroff". - "@{[weechat::color('-underline')]} command did not produce". - " any output.", - "Working pod2man and nroff commands are required for the ". - "help viewer to work.", - "In the meantime, please use the command ", '', - "\tperldoc $file", '', - "on your shell instead in order to read the manual.", - "Thank you and sorry for the inconvenience." + unless ($buf->{lines}{lines_count} > 0) { + $buf->print(W->prefix('error').$_) + for ("Unfortunately, your @{[W->color('underline')]}nroff". + "@{[W->color('-underline')]} command did not produce". + " any output.", + "Working pod2man and nroff commands are required for the ". + "help viewer to work.", + "In the meantime, please use the command ", '', + "\tperldoc $file", '', + "on your shell instead in order to read the manual.", + "Thank you and sorry for the inconvenience."); } } 1 -} + } }; +#$$$ }autoloaded -weechat::bar_item_new('main_menu', 'bar_item_main_menu', ''); -weechat::bar_item_new('sub_menu', 'bar_item_sub_menu', ''); -weechat::bar_item_new('menu_help', 'bar_item_menu_help', ''); -weechat::bar_item_new('window_popup_menu', 'bar_item_window_popup_menu', ''); -weechat::hook_command(SCRIPT_NAME, 'open the menu', '[name] [args] || reset', - 'without arguments, open the main menu.'."\n". - 'if name is given, open the popup menu with that name - this is usually done by scripts.' - ."\n".'args are passed on to the menu commands, see the manual for more info.'."\n". - 'Example: /menu nick yournick'."\n". - 'reset: resets the menu system to its initial config (also required if '."\n". - ' you want to load new default menus, e.g after upgrade of script)'."\n". - 'use '.weechat::color('bold').'/menu help'.weechat::color('-bold'). - ' to read the manual', '', 'open_menu', ''); -weechat::hook_signal('buffer_closed', 'invalidate_popup_buffer', ''); -weechat::hook_signal('mouse', 'mouse_evt', ''); -weechat::hook_signal('input_flow_free', 'menu_input_mouse_fix', ''); -weechat::hook_config('plugins.var.perl.'.SCRIPT_NAME.'.*', 'script_config', ''); -weechat::hook_config(SCRIPT_NAME.'.var.*', 'menu_config', ''); -weechat::hook_command_run('/key *', 'update_main_menu', ''); +W->register(SCRIPT_NAME, 'Nei ', $VERSION, 'GPL3', 'menu system', 'stop_menu', '') + || return; +our $SCRIPT_FILE = W->_infolist('perl_script', '', SCRIPT_NAME)->[0]{filename}; + +W->bar_item_new('main_menu', 'bar_item_main_menu', ''); +W->bar_item_new('sub_menu', 'bar_item_sub_menu', ''); +W->bar_item_new('menu_help', 'bar_item_menu_help', ''); +W->bar_item_new('window_popup_menu', 'bar_item_window_popup_menu', ''); +W->hook_command(SCRIPT_NAME, 'open the menu', '[name] [args] || reset', + (join "\n", + 'without arguments, open the main menu.', + 'if name is given, open the popup menu with that name - this is usually done by scripts.', + 'args are passed on to the menu commands, see the manual for more info.', + 'Example: /menu nick yournick', + 'reset: resets the menu system to its initial config (also required if ', + ' you want to load new default menus, e.g after upgrade of script)', + 'use '.W->color('bold').'/menu help'.W->color('-bold').' to read the manual' + ), '', 'open_menu', ''); +W->hook_signal('input_flow_free', 'multiline_fix', ''); +W->hook_signal('buffer_closed', 'invalidate_popup_buffer', ''); +W->hook_config('plugins.var.perl.'.SCRIPT_NAME.'.*', 'script_config', ''); +W->hook_config(SCRIPT_NAME.'.var.*', 'menu_config', ''); +W->hook_command_run('/key *', 'update_main_menu', ''); # is there builtin mouse support? -if ((weechat::info_get('version_number', '') || 0) >= 0x00030600) { - weechat::hook_hsignal('menu', 'hsignal_evt', ''); - weechat::key_bind('mouse', +{ - map { $_ => 'hsignal:menu' } - '@bar(*_menu):button1', - '@item(buffer_nicklist):button1' - }); +if ((W->info_get('version_number', '') || 0) >= 0x00030600) { + W->hook_hsignal('menu', 'hsignal_evt', ''); + W->key_bind('mouse', +{ + map { $_ => 'hsignal:menu' } + '@bar(*_menu):button1', + '@item(buffer_nicklist):button1' + }); } our %ACT_MENU; @@ -802,21 +933,22 @@ our $POPUP_MENU; our $POPUP_MENU_ARGS; our $MENU_OPEN; -our $MOUSE_IN_PROGRESS; - -our ($CFG_FILE, $CFG_FILE_SECTION); - -our $last_mouse_seq; +our $INPUT_IN_PROGRESS; our $LAST_NICK_COLOR; -our ($NICKLIST_RESCROLL_X, $NICKLIST_RESCROLL_Y); -our ($LAST_NICKLIST_RESCROLL_X, $LAST_NICKLIST_RESCROLL_Y); - -use constant DEBUG_MENU => 0; +our ($CFG_FILE, $CFG_FILE_SECTION); init_menu(); +sub bool_value { W->config_string_to_boolean(@_) } +sub wee_eval { + if ((W->info_get('version_number', '') || 0) >= 0x00040200) { + push @_, ''; + } + Wstr->eval_expression(@_); +} + ## make_menu -- convert menu entries to bar items ## $items - array ref of menu entries ## $active - reference to active menu item (gets corrected for bounds) @@ -825,246 +957,401 @@ ## $title - menu title (if applicable) ## returns bar item structure of menu items sub make_menu { - my ($items, $active, $prefix, $info, $title) = @_; - if (defined $$active) { - $$active = $#$items if $$active < 0; - $$active = 0 if $$active > $#$items; - } - my ($ul, $UL) = map { weechat::color($_) } ('underline', '-underline'); - s/&(.)/$ul$1$UL/g for @$items; - my $I = '▐'; - my $act_menu = $MENU_OPEN && defined $$active ? $$active : -1; - my $act = weechat::color('reverse'); - my $ACT = weechat::color('-reverse'); - join "\n", (defined $title ? $title !~ /\S/ ? $title : $I.$act.$title.$I.$ACT : ()), - map { $prefix.$_ } map { $act_menu-- ? $_ : $act.$_ } @$items, - (($MENU_OPEN || !$info) ? () : $I.$act.$info.$I.$ACT) + my ($items, $active, $prefix, $info, $title) = @_; + my @items = @$items; + if (defined $$active) { + $$active = $#items if $$active < 0; + $$active = 0 if $$active > $#items; + } + my ($ul, $UL) = map { W->color($_) } ('underline', '-underline'); + s/&(.)/$ul$1$UL/g for @items; + my $I = '▐'; + my $act_menu = $MENU_OPEN && defined $$active ? $$active : -1; + my $act = W->color('reverse'); + my $ACT = W->color('-reverse'); + join "\n", (defined $title ? $title !~ /\S/ ? $title : "$I$act$title$I$ACT" : ()), + map { "$prefix$_" } map { $act_menu-- ? $_ : "$act$_" } @items, + (($MENU_OPEN || !$info) ? () : "$I$act$info$I$ACT") } ## MAIN_MENU -- return main menu items sub MAIN_MENU { - map { $_->{'value'} } - grep { $_->{'option_name'} =~ /^\d+[.]name$/ } - Nlib::i2h('option', '', 'menu.var.*') - #qw(&File &Edit &View C&mds &Tools &Options &Buffers &Perl) + map { $_->{value} } + grep { $_->{option_name} =~ /^\d+[.]name$/ } + W->_infolist('option', '', 'menu.var.*') +} + +{ + my %int_repl = ('meta-' => "\1[", 'meta2-' => "\1[[", 'ctrl-' => "\1"); + my $int_repl = join '|', map { quotemeta } sort { length $b <=> length $a } keys %int_repl; + my %int_repl_rev = reverse %int_repl; + my $int_repl_rev = join '|', map { quotemeta } sort { length $b <=> length $a } keys %int_repl_rev; + my $area_re = qr/\@(?:\w|[](.>*)[])*:/; + + my %arrow = (A => '↑', B => '↓', C => '→', D => '←', E => '·'); + my %no_arrow = (Up => '↑', Down => '↓', Right => '→', Left => '←', Begin => '·'); + my %no_arrow_disp = reverse %no_arrow; + $no_arrow{KP5} = $no_arrow{Center} = $no_arrow{Begin}; + my %inspg = (2 => 'Ins', 3 => 'Del', 5 => 'PgUp', 6 => 'PgDn', + 1 => 'Find', 4 => 'Select', + 28 => 'Help', 29 => 'Copy', 32 => 'Paste', 34 => 'Cut', + (map { 11+$_ => "F$_" } 6..10), + (map { 12+$_ => "F$_" } 11..12), + ); + my %fkeys = (P => 'F1', Q => 'F2', R => 'F3', S => 'F4'); + my %homend = (H => 'Home', F => 'End'); + my %homend1 = (7 => $homend{H}, 8 => $homend{F}, + (map { 10+$_ => "F$_" } 1..5), + ); + my %homend2 = (1 => $homend{H}, 4 => $homend{F}); + # C-M-S- + my %csi_mod_map = (2 => 'S-', 3 => 'M-', 4 => 'M-S-', 5 => 'C-', 6 => 'C-S-', 7 => 'C-M-', 8 => 'C-M-S-'); + my %csi_mod_meta = ( 9 => 'M-', 10 => 'M-S-', 13 => 'C-M-', 14 => 'C-M-S-'); + # 11 => 'M-A-', 12 => 'M-A-S-', 15 => 'C-M-A-', 16 => 'C-M-A-S-' + my %rxvt_mod_map = ('^' => 'C-', '$' #' + => 'S-', '@' => 'C-S-'); + ## &$apply_tpl -- apply template parameters according to variable hash + ## $r - hashref with key template in key 't'. %X are replaced by $r->{X} + ## returns pair of keyseq and label/tag + my $apply_tpl = sub { + my $r = shift; + my @r = ($r->{t}[0], ref $r->{t}[1] ? [ @{$r->{t}[1]} ] : [ $r->{t}[1] ]); + push @{$r[1]}, 'meta' if exists $r->{E} && $r->{E}[0] =~ /^\d+$/ && $r->{E}[0] >= 9; + $r[0] =~ s/%(\w)/${$r}{$1}[0]/g; + $r[0] =~ s/\\l(.)/\l$1/g; + for ($r[1][0]) { + s/\%(\w)/${$r}{$1}[1]/g; + s/M-C-/C-M-/g; + } + $r[1] = $r[1][0] if @{$r[1]} == 1; + @r + }; + + ## &$map_key_add -- adds keys and its values to template replacement hash + ## $rr - template hashref + ## $f - variable name (1 char) + ## $t - hashref with keys/values to iterate through + ## $subr - subroutine ref that is called for each key/value + ## returns list of $subr results applied to all entries in $t + my $map_key_add = sub { + my ($rr, $f, $t, $subr) = @_; + map { + $rr->{$f} = [ $_ => $t->{$_} ]; + $subr->($rr) + } keys %$t + }; + + ## &$map_hashlist -- call &$map_key_add for all hashrefs in list + ## $rr - template hashref + ## $f - variable name (1 char) + ## @list - list of hashrefs with keys/values to iterate through + ## $subr - subroutine ref that is called for each key/value + ## returns list of $subr results applied to all entries in all hashs of @list + my $map_hashlist = sub { + my ($rr, $f, @list) = @_; + my $subr = pop @list; + map { + $map_key_add->($rr, $f, $_, $subr) + } @list + }; + + ## &$apply_tpl_fun -- functor to run &$apply_tpl + ## $_[0] - hashref with template and parameters + ## see &$apply_tpl + my $apply_tpl_fun = sub { + $apply_tpl->(+shift) + }; + + ## &$variable_e -- calls &$map_hashlist for keys and a list of hashes that are used for the %E template variable + ## $e - arrayref of hashrefs which provide values for %E + ## $_[1] - key template + ## $_[2..$#@] - list of hashrefs which provide key seqs and definitions (%K) + ## returns list of template expansion applied to all %E and %K values + my $variable_e = sub { + my $e = shift; + $map_hashlist->( + +{ t => +shift }, + K => @_, + sub { + $map_hashlist->( + +shift, + E => @$e, + $apply_tpl_fun + ) + } + ) + }; + + my %H = ( + ## &$H{def_end} -- apply %K template like meta2-%K => %K + ## $_[0] - key template + ## $_[1..$#@] - list of hashrefs providing %K + ## returns list of template expansion applied to all %K values + def_end => sub { + $map_hashlist->( + +{ t => +shift }, + K => @_, + $apply_tpl_fun + ) + }, + ## &$H{csi_end} -- apply %E%K template, %E iterates over csi codes + ## $_[0] - key template + ## $_[1..$#@] - list of hashrefs providing %K + ## returns list of template expansion applied to all %E and %K values + csi_end => sub { + $variable_e->( + [\(%csi_mod_map, %csi_mod_meta)], + @_ + ) + }, + ## &$H{rxvt_end} -- apply %E%K template, %E iterates over rxvt modifier codes (note: there is no modifier for meta) + ## $_[0] - key template + ## $_[1..$#@] - list of hashrefs providing %K + ## returns list of template expansion applied to all %E and %K values + rxvt_end => sub { + $variable_e->( + [\%rxvt_mod_map], + @_ + ) + }, + ## &$H{and_meta_pfx} -- add meta-/M- to the list of key mappings + ## @_ - list of sequence => name/tag pairs to which to add a meta variant + ## returns the original hash plus a copy of it with meta- added in front + and_meta_pfx => sub { + my %ht = @_; + map { + ($_ => $ht{$_}, + "meta-$_" => do { + my @r = ref $ht{$_} ? @{$ht{$_}} : $ht{$_}; + $r[0] = "M-$r[0]"; + $r[0] =~ s/M-C-/C-M-/g; + @r == 1 ? $r[0] : \@r }) + } keys %ht + }, + ); + my %reverse_some_keys; + my %some_keys = ( + 'meta2-P' => 'Pause', + + 'ctrl-@' => 'C-SPC', + + 'ctrl-I' => 'Tab', + 'meta2-Z' => 'S-Tab', + 'meta2-27;5;9~' => 'C-Tab', + + $H{and_meta_pfx}( + 'ctrl-M' => 'RET', + ), + 'meta2-27;5;13~' => 'C-RET', + 'meta2-27;2;13~' => 'S-RET', + + $H{and_meta_pfx}( + 'ctrl-?' => 'BS', + 'ctrl-H' => 'C-BS', + ), + + $H{def_end}([ 'meta2-%K' => '%K' ], \%arrow, \%homend), + $H{csi_end}([ 'meta2-1;%E%K' => '%E%K' ], \%arrow, \%fkeys, \%homend), + + $H{def_end}([ 'meta-O%K' =>['C-%K','tmux'] ], \%arrow), + $H{def_end}([ 'meta-O\l%K' =>['C-%K','rxvt'] ], \%arrow), + $H{def_end}([ 'meta2-\l%K' =>['S-%K','rxvt'] ], \%arrow), + $H{def_end}([ 'meta-meta2-%K' =>['M-%K','rxvt'] ], \%arrow), + + $H{def_end}([ 'meta-O%K' => '%K' ], \%fkeys), + $H{def_end}([ 'meta-meta-O%K' =>['M-%K','tmux'] ], \%fkeys), + + $H{def_end}([ 'meta2-%K~' => '%K' ], \%inspg), + $H{csi_end}([ 'meta2-%K;%E~' => '%E%K' ], \%inspg), + + $H{and_meta_pfx}( + $H{rxvt_end}(['meta2-%K%E' =>['%E%K','rxvt'] ], \%inspg), + ), + $H{def_end}([ 'meta-meta2-%K~'=>['M-%K','rxvt'] ], \%inspg), + + $H{and_meta_pfx}( + $H{def_end}([ 'meta2-%K~' =>[ '%K','rxvt'] ], \%homend1), + $H{rxvt_end}(['meta2-%K%E' =>['%E%K','rxvt'] ], \%homend1), + ), + + $H{def_end}([ 'meta-meta2-%K~'=>['M-%K','screen']],\%homend2), + + 'meta2-200~' => 'PasteBegin', + 'meta2-201~' => 'PasteEnd', + ); + my %int_some_keys = ("\1[" => 'M-', "\1" => 'C-', "\1[[" => 'meta2-'); + my $no_arrow_disp = '[' . (join '', keys %no_arrow_disp) . ']'; + for (sort { ref $some_keys{$a} && ref $some_keys{$b} + ? $some_keys{$a}[0] cmp $some_keys{$b}[0] + : ref $some_keys{$b} ? -1 + : ref $some_keys{$a} ? 1 + : $some_keys{$a} cmp $some_keys{$b} } keys %some_keys) { + push @{$reverse_some_keys{ ref $some_keys{$_} ? $some_keys{$_}[0] : $some_keys{$_} }}, + ref $some_keys{$_} ? [ $_, $some_keys{$_}[1] ] : $_; + my $o = $_; + s/($int_repl)/$int_repl{$1}/g; + $int_some_keys{$_} = $some_keys{$o}; + } + for (keys %no_arrow) { + for my $pfx ('', 'C-', 'S-', 'M-', 'C-M-', 'C-S-', 'C-M-S-', 'M-S-') { + push @{$reverse_some_keys{"$pfx$_"}}, @{$reverse_some_keys{"$pfx$no_arrow{$_}"}} + if exists $reverse_some_keys{"$pfx$no_arrow{$_}"}; + } + } + my $keys_internal = join '|', map { quotemeta } sort { length $b <=> length $a } keys %int_some_keys; + + sub rename_key { + my $keybinding = shift; + return wantarray ? ($keybinding->{key}, []) : $keybinding->{key} + if $keybinding->{key} eq $keybinding->{key_internal}; + $keybinding = $keybinding->{key_internal}; + my $area = $1 if $keybinding =~ s/^($area_re)//; + my @ann; + $keybinding =~ s{($keys_internal|\w|\p{Print})}{ + (exists $int_some_keys{$1} + ? ref $int_some_keys{$1} + ? ((push @ann, $int_some_keys{$1}[1]), + $int_some_keys{$1}[0]) + : $int_some_keys{$1} + : $1).' '}ge; + $keybinding =~ s/C- \K(\w)/\L$1/g; + $keybinding =~ s/M- O (?=\p{Print})/meta-O /g; + $keybinding =~ s/M-C-/C-M-/g; + $keybinding =~ s/\w-\K //g; + $keybinding = "$area$keybinding" if defined $area; + unshift @ann, '|unknown|' if $keybinding =~ /meta(?:2-|-O)/; + wantarray ? ($keybinding, \@ann) : $keybinding + } } ## bar_item_main_menu -- return main menu as bar items sub bar_item_main_menu { - my @items = MAIN_MENU(); - my ($keybinding) = grep { $_->{'command'} eq '/menu' } Nlib::i2h('key'); - if ($keybinding) { - my %arrow = ('A' => '↑', 'B' => '↓', 'C' => '→', 'D' => '←', 'E' => '·'); - my %inspg = (2 => 'Ins', 3 => 'Del', 5 => 'PgUp', 6 => 'PgDn', - 1 => 'Find', 28 => 'Help', 29 => 'Copy', 32 => 'Paste', 34 => 'Cut', - (map { 10+$_ => "F$_" } 1..5), - (map { 11+$_ => "F$_" } 6..10), - (map { 12+$_ => "F$_" } 11..12), - ); - my %fkeys = ('P' => 'F1', 'Q' => 'F2', 'R' => 'F3', 'S' => 'F4'); - my %homend = ('H' => 'Home', 'F' => 'End'); - my %homend1 = (7 => $homend{'H'}, 8 => $homend{'F'}); - my %homend2 = (1 => $homend{'H'}, 4 => $homend{'F'}); - my %some_keys = ( - 'meta2-P' => 'Pause', - - 'ctrl-@' => 'C-SPC', - - 'ctrl-I' => 'Tab', - 'meta2-Z' => 'S-Tab', - 'meta2-27;5;9~' => 'C-Tab', - - 'ctrl-M' => 'RET', - 'meta2-27;5;13~' => 'C-RET', - 'meta2-27;2;13~' => 'S-RET', - 'meta-ctrl-M' => 'M-RET', - - 'ctrl-?' => 'BS', - 'ctrl-H' => 'C-BS', - 'meta-ctrl-?' => 'M-BS', - 'meta-ctrl-H' => 'C-M-BS', - - (map { ( "meta2-$_" => $arrow{$_} ) } keys %arrow), - (map { ( "meta2-1;5$_" => "C-$arrow{$_}" ) } keys %arrow), - (map { ( "meta-O$_" => "C-$arrow{$_}" ) } keys %arrow), - (map { ( "meta-O\l$_" => "C-$arrow{$_}" ) } keys %arrow), - (map { ( "meta2-1;2$_" => "S-$arrow{$_}" ) } keys %arrow), - (map { ( "meta2-\l$_" => "S-$arrow{$_}" ) } keys %arrow), - (map { ( "meta2-1;3$_" => "M-$arrow{$_}" ) } keys %arrow), - (map { ( "meta-meta2-$_" => "M-$arrow{$_}" ) } keys %arrow), - - (map { ( "meta-O$_" => $fkeys{$_} ) } keys %fkeys), - (map { ( "meta2-1;5$_" => "C-$fkeys{$_}" ) } keys %fkeys), - (map { ( "meta2-1;2$_" => "S-$fkeys{$_}" ) } keys %fkeys), - (map { ( "meta2-1;3$_" => "M-$fkeys{$_}" ) } keys %fkeys), - (map { ( "meta-meta-O$_" => "M-$fkeys{$_}" ) } keys %fkeys), - - (map { ( "meta2-$_" => $homend{$_} ) } keys %homend), - (map { ( "meta2-1;5$_" => "C-$homend{$_}" ) } keys %homend), - (map { ( "meta2-1;2$_" => "S-$homend{$_}" ) } keys %homend), - (map { ( "meta2-1;3$_" => "M-$homend{$_}" ) } keys %homend), - - (map { ( "meta2-$_~" => $inspg{$_} ) } keys %inspg), - (map { ( "meta2-$_;5~" => "C-$inspg{$_}" ) } keys %inspg), - (map { ( "meta2-${_}ctrl-^" => "C-$inspg{$_}" ) } keys %inspg), - (map { ( "meta2-$_;2~" => "S-$inspg{$_}" ) } keys %inspg), - (map { ( "meta2-$_\$" => "S-$inspg{$_}" ) } keys %inspg), - (map { ( "meta2-$_;3~" => "M-$inspg{$_}" ) } keys %inspg), - (map { ( "meta-meta2-$_~" => "M-$inspg{$_}" ) } keys %inspg), - - (map { ( "meta2-$_~" => $homend1{$_} ) } keys %homend1), - (map { ( "meta2-${_}ctrl-^" => "C-$homend1{$_}" ) } keys %homend1), - (map { ( "meta2-$_\$" => "S-$homend1{$_}" ) } keys %homend1), - (map { ( "meta-meta2-$_~" => "M-$homend1{$_}" ) } keys %homend1), - (map { ( "meta-meta2-$_~" => "M-$homend2{$_}" ) } keys %homend2), - ); - $keybinding = $keybinding->{'key'}; - if (exists $some_keys{$keybinding}) { - $keybinding = $some_keys{$keybinding}; - } - else { - $keybinding =~ s/meta-/M-/; - $keybinding =~ s/ctrl-(.)/C-\l$1/; - $keybinding =~ s/M-C-/C-M-/; - } - } - else { - $keybinding = '/menu'; - } - make_menu(\@items, (!$MENU_OPEN || $MENU_OPEN < 3 ? \$ACT_MENU{'main'} : \undef), '', $keybinding.' to open menu') + my @items = MAIN_MENU(); + my ($keybinding) = grep { $_->{command} eq '/menu' } W->_infolist('key'); + if ($keybinding) { + $keybinding = rename_key($keybinding); + } + else { + $keybinding = '/menu'; + } + my $key_hint_text = "$keybinding to open menu"; + $key_hint_text = '' if W->config_is_set_plugin('key_binding_hidden') && bool_value(W->config_get_plugin('key_binding_hidden')); + make_menu(\@items, (!$MENU_OPEN || $MENU_OPEN < 3 ? \$ACT_MENU{main} : \undef), '', $key_hint_text) } ## menu_input_run -- dispatch /input actions to menu ## () - event handler ## $cmd - executed /input command sub menu_input_run { - my (undef, undef, $cmd) = @_; - return weechat::WEECHAT_RC_OK unless $MENU_OPEN; - $cmd =~ s/ (?:insert \\x0a|magic_enter)/ return/; - if ($cmd eq '/input delete_previous_char') { - my $bar = weechat::bar_search('menu_help'); - my $hidden = (Nlib::i2h('bar', $bar))[0]{'hidden'}; - weechat::bar_set($bar, 'hidden', $hidden ? 0 : 1); - weechat::bar_set(weechat::bar_search('sub_menu'), 'separator', $hidden ? 0 : 1); - weechat::config_set_plugin('active_help', $hidden ? 'on' : 'off'); - if ($MENU_OPEN == 3 && $POPUP_MENU eq 'nick') { - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * x+$LAST_NICKLIST_RESCROLL_X") if $LAST_NICKLIST_RESCROLL_X; - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * y+$LAST_NICKLIST_RESCROLL_Y") if $LAST_NICKLIST_RESCROLL_Y; - } - } - elsif ($MENU_OPEN == 1) { - if ($cmd eq '/input switch_active_buffer') { - close_menu(); - } - elsif ($cmd eq '/input move_previous_char') { - --$ACT_MENU{'main'}; - update_main_menu(); - } - elsif ($cmd eq '/input move_next_char') { - ++$ACT_MENU{'main'}; - update_main_menu(); - } - elsif ($cmd eq '/input return') { - ++$MENU_OPEN; - open_submenu(); - } - } - elsif ($MENU_OPEN == 2) { - if ($cmd eq '/input switch_active_buffer') { - close_submenu(); - --$MENU_OPEN; - } - elsif ($cmd eq '/input history_previous' || $cmd eq '/input history_global_previous') { - --$ACT_MENU{'sub'}; - update_sub_menu(); - } - elsif ($cmd eq '/input history_next' || $cmd eq '/input history_global_next') { - ++$ACT_MENU{'sub'}; - update_sub_menu(); - } - elsif ($cmd eq '/input return') { - exec_submenu(); - open_menu() unless weechat::config_is_set_plugin('sticky_menu') && Nlib::has_true_value(weechat::config_get_plugin('sticky_menu')); - } - #return weechat::WEECHAT_RC_OK + my (undef, undef, $cmd) = @_; + return WC->RC_OK unless $MENU_OPEN; + $cmd =~ s/ (?:insert \\x0a|magic_enter)/ return/; + if ($cmd eq '/input delete_previous_char') { # toggle help + my $bar = W->bar_search('menu_help'); + $bar->{hidden} = 0 + !$bar->_infolist->{hidden}; + W->bar_search('sub_menu')->{separator} = 0 + $bar->_infolist->{hidden}; + W->config_set_plugin('active_help', $bar->_infolist->{hidden} ? 'on' : 'off'); + } + else { + my $mo = menu_stuff(); + if ($cmd eq '/input switch_active_buffer') { + $mo->{close}->(); + --$MENU_OPEN if defined $MENU_OPEN; + } + elsif ($cmd eq '/input move_previous_char' + || $cmd eq '/input history_previous' || $cmd eq '/input history_global_previous') { + --${ $mo->{act} }; + $mo->{update}->(); + } + elsif ($cmd eq '/input move_next_char' + || $cmd eq '/input history_next' || $cmd eq '/input history_global_next') { + ++${ $mo->{act} }; + $mo->{update}->(); + } + elsif ($cmd eq '/input return') { + $mo->{exec}->(); + open_menu() unless $mo->{main} + || (W->config_is_set_plugin('sticky_menu') && bool_value(W->config_get_plugin('sticky_menu'))); } - elsif ($MENU_OPEN == 3) { - if ($cmd eq '/input switch_active_buffer') { - close_window_popup_menu(); - close_menu(); - } - elsif ($cmd eq '/input history_previous' || $cmd eq '/input history_global_previous') { - --$ACT_MENU{'window_popup'}; - update_window_popup_menu(); - } - elsif ($cmd eq '/input history_next' || $cmd eq '/input history_global_next') { - ++$ACT_MENU{'window_popup'}; - update_window_popup_menu(); - } - elsif ($cmd eq '/input return') { - exec_popupmenu(); - open_menu() unless weechat::config_is_set_plugin('sticky_menu') && Nlib::has_true_value(weechat::config_get_plugin('sticky_menu')); - } - } - else { - if ($cmd eq '/input switch_active_buffer') { - open_menu(); # close here - } - } - weechat::WEECHAT_RC_OK_EAT + } + WC->RC_OK_EAT +} + +## menu_stuff -- get active menu +## returns active item storage, update func and menu item func of active menu +{ + my %MENU_STUFF = ( + 1 => +{ + close => \&close_menu, + update => \&update_main_menu, + main => 1, + exec => sub { + ++$MENU_OPEN; + open_submenu(); + }, + act => \($ACT_MENU{main}), + items => \&MAIN_MENU + }, + 2 => +{ + close => \&close_submenu, + update => \&update_sub_menu, + exec => \&exec_submenu, + act => \($ACT_MENU{sub}), + items => \&SUB_MENU + }, + 3 => +{ + close => sub { + close_window_popup_menu(); + close_menu(); + }, + update => \&update_window_popup_menu, + exec => \&exec_popupmenu, + act => \($ACT_MENU{window_popup}), + items => \&WINDOW_POPUP_MENU + }, + '' => +{ + close => \&open_menu, + main => 1, + update => sub{}, + exec => \&open_menu, + act => \(my $o = 0), + items => sub{}, + } + ); + + sub menu_stuff { + $MENU_STUFF{$MENU_OPEN} || $MENU_STUFF{''}; + } } ## menu_input_mouse_fix -- disable shortcuts during mouse input ## () - signal handler -sub menu_input_mouse_fix { - (undef, undef, $MOUSE_IN_PROGRESS) = @_; +sub multiline_fix { + (undef, undef, $INPUT_IN_PROGRESS) = @_; weechat::WEECHAT_RC_OK } -## menu_stuff -- get active menu -## returns active item storage, update func and menu item func of active menu -sub menu_stuff { - if ($MENU_OPEN == 1) { - \($ACT_MENU{'main'}, - &update_main_menu, - &MAIN_MENU) - } - elsif ($MENU_OPEN == 2) { - \($ACT_MENU{'sub'}, - &update_sub_menu, - &SUB_MENU) - } - elsif ($MENU_OPEN == 3) { - \($ACT_MENU{'window_popup'}, - &update_window_popup_menu, - &WINDOW_POPUP_MENU) - } - else { - (\'', sub {}, sub {}) - } -} - ## menu_input_text -- read input shortcut keys ## () - event handler ## $_[3] - current content of input buffer ## removes input shortcut key and returns old content of input buffer sub menu_input_text { - Encode::_utf8_on($_[3]); - return $_[3] unless $MENU_OPEN; - return $_[3] if $MOUSE_IN_PROGRESS; - my $buf = weechat::current_buffer(); - my $npos = weechat::buffer_get_integer($buf, 'input_pos')-1; - my $input_key = substr $_[3], $npos, 1, ''; - my ($act_store, $update_fun, $menu_fun) = menu_stuff(); - my ($pos) = map { $_->[0] } - grep { $_->[-1] =~ /&\Q$input_key/i } - do { my $i = 0; map { [ $i++, $_ ] } $menu_fun->() }; - if (defined $pos) { - $$act_store = $pos; - $update_fun->(); - } - weechat::buffer_set($buf, 'input_pos', $npos); - $_[3] + Encode::_utf8_on($_[3]); + return $_[3] unless $MENU_OPEN; + return $_[3] if $INPUT_IN_PROGRESS; + my $mo = menu_stuff; + my $buf = W->current_buffer(); + my $npos = $buf->{input_buffer_pos}-1; + my $input_key = substr $_[3], $npos, 1, ''; + my ($pos) = map { $_->[0] } + grep { $_->[-1] =~ /&\Q$input_key/i } + do { my $i = 0; map { [ $i++, $_ ] } $mo->{items}->() }; + if (defined $pos) { + ${ $mo->{act} } = $pos; + $mo->{update}->(); + } + $buf->{input_pos} = $npos; + $_[3] } ## menu_input_text_display -- display on input bar @@ -1072,304 +1359,243 @@ ## $_[3] - current content of input buffer ## returns text to be displayed on input bar sub menu_input_text_display { - Encode::_utf8_on($_[3]); - return $_[3] unless $MENU_OPEN; - '[menu open'.($MOUSE_IN_PROGRESS ? ' (mouse input)' : '').'] '. $_[3] -} - -## mouse_nicklist -- handle mouse click on nicklist -## () - forwarded signal handler -## $_[2] - mouse code -## $bar_infos - info about bar -## $in_any_win - info about parent window -## $col - pointer column in bar -## $row - pointer row in bar -sub mouse_nicklist { - my (undef, undef, undef, $bar_infos, $in_any_win, $col, $row) = @_; - my ($error, $idx, $item) = - Nlib::bar_item_get_subitem_at($bar_infos, qr/\bbuffer_nicklist\b/, $col, $row); - return weechat::WEECHAT_RC_OK if $error; - my @nick_format = split "\01", weechat::string_remove_color($item, "\1"); - weechat::print('', join ' :: ', @nick_format) if DEBUG_MENU; - my $nick = @nick_format ? $nick_format[-1] : undef; - return weechat::WEECHAT_RC_OK unless defined $nick; - return weechat::WEECHAT_RC_OK unless $in_any_win; - my $bufptr = $in_any_win->{'buffer'}; - mouse_nicklist_barcode($bar_infos, undef, $_[2], $bufptr, $nick, $item); + Encode::_utf8_on($_[3]); + return $_[3] unless $MENU_OPEN; + '[menu open] '. $_[3] } sub mouse_nicklist_barcode { - my ($bar_infos, undef, undef, $bufptr, $nick, $item) = @_; - my $nickptr = weechat::nicklist_search_nick($bufptr, '', $nick); + my (undef, undef, undef, $bufptr, $nick, $item) = @_; + my $nickptr = $bufptr->nicklist_search_nick('', $nick); if ($nickptr) { my @funargs = ($bufptr, $nickptr, 'color'); - weechat::nicklist_nick_set(@$LAST_NICK_COLOR) if $LAST_NICK_COLOR; - $LAST_NICK_COLOR = [ @funargs, weechat::nicklist_nick_get_string(@funargs) ]; - weechat::nicklist_nick_set(@funargs, 'reverse'); - } - ($NICKLIST_RESCROLL_X, $NICKLIST_RESCROLL_Y) = - ($bar_infos->[0]{'scroll_x'},$bar_infos->[0]{'scroll_y'}) if defined $bar_infos; - - weechat::command(weechat::current_buffer(), "/menu nick $nick") if $_[2] =~ /^#/; - weechat::WEECHAT_RC_OK -} - -## mouse_evt -- handle mouse clicks -## () - signal handler -## $_[2] - mouse code -sub mouse_evt { - Encode::_utf8_on($_[2]); - my $this_last_mouse_seq = $last_mouse_seq || ''; - $last_mouse_seq = $_[2]; - - if ($_[2] =~ /^[# ](.)(.)$/) { - my $row = ord($2)-32; - my $col = ord($1)-32; - - my $bar_infos = Nlib::find_bar_window($row, $col); - return weechat::WEECHAT_RC_OK unless $bar_infos; - - my @all_windows = Nlib::i2h('window'); - my $in_any_win; - for (@all_windows) { - $in_any_win = $_ if Nlib::in_window($row, $col, $_); - } - - $col -= $bar_infos->[0]{'x'}; - $row -= $bar_infos->[0]{'y'}; - - weechat::print('', join ' :: ', $bar_infos->[-1]{'name'}, - (map { defined $_ ? $_ : '(undef)' } - Nlib::bar_item_get_item_and_subitem_at - ($bar_infos, $col, $row))) if DEBUG_MENU; - - return mouse_nicklist(@_[0..2], $bar_infos, $in_any_win, $col, $row) - if $bar_infos->[-1]{'name'} eq 'nicklist'; - - return weechat::WEECHAT_RC_OK - unless $bar_infos->[-1]{'name'} =~ '_menu$'; - - return mouse_evt_barcode($bar_infos, undef, $_[2], - Nlib::bar_item_get_subitem_at($bar_infos, qr/_menu\b/, $col, $row)); - + W->nicklist_nick_set(@$LAST_NICK_COLOR) if $LAST_NICK_COLOR; + $LAST_NICK_COLOR = [ @funargs, W->nicklist_nick_get_string(@funargs) ]; + W->nicklist_nick_set(@funargs, 'reverse'); } - weechat::WEECHAT_RC_OK + W->current_buffer()->command("/menu nick $nick"); + WC->RC_OK } sub mouse_evt_barcode { - my ($bar_infos, undef, undef, $error, $idx, $item) = @_; + my (undef, undef, undef, $error, $idx, $item, $bar_name) = @_; my $close_menu_in_empty = qr/_menu\b/; # qr/\bmain_menu\b/; if ($error) { open_menu() # closes the menu here - if ($MENU_OPEN && !defined $idx && $bar_infos->[-1]{'name'} =~ $close_menu_in_empty && $_[2] =~ /^#/); + if ($MENU_OPEN && !defined $idx && $bar_name =~ $close_menu_in_empty); - if (DEBUG_MENU) { - $idx = '(undef)' unless defined $idx; - $item = '(undef)' unless defined $item; - weechat::print('', "thing: $error @ $idx [ $item ]"); - } - return weechat::WEECHAT_RC_OK; + return WC->RC_OK; } - if ($bar_infos->[-1]{'name'} =~ /\bmain_menu\b/) { + if ($bar_name =~ /\bmain_menu\b/) { open_menu() unless $MENU_OPEN; - if ($ACT_MENU{'main'} == $idx && $MENU_OPEN == 2 && $_[2] =~ /^#/ - ) { - #open_menu(); - #return weechat::WEECHAT_RC_OK - } menu_input_run('', '', '/input switch_active_buffer') while ($MENU_OPEN > 1); - $ACT_MENU{'main'} = $idx; + $ACT_MENU{main} = $idx; update_main_menu(); - menu_input_run('', '', '/input return') if $_[2] =~ /^#/; + menu_input_run('', '', '/input return'); } - elsif ($bar_infos->[-1]{'name'} =~ /\bsub_menu\b/) { + elsif ($bar_name =~ /\bsub_menu\b/) { open_menu() unless $idx; - $ACT_MENU{'sub'} = $idx-1 if $idx; + $ACT_MENU{sub} = $idx-1 if $idx; update_sub_menu(); - menu_input_run('', '', '/input return') if $_[2] =~ /^#/; + menu_input_run('', '', '/input return'); } - elsif ($bar_infos->[-1]{'name'} =~ /\bwindow_popup_menu\b/) { + elsif ($bar_name =~ /\bwindow_popup_menu\b/) { open_menu() unless $idx; - $ACT_MENU{'window_popup'} = $idx-1 if $idx; + $ACT_MENU{window_popup} = $idx-1 if $idx; update_window_popup_menu(); - menu_input_run('', '', '/input return') if $_[2] =~ /^#/; + menu_input_run('', '', '/input return'); } - weechat::WEECHAT_RC_OK -} + WC->RC_OK + } sub hsignal_evt { - my %data = %{$_[2]}; - return mouse_nicklist_barcode(undef, - undef, - '#', - $data{_buffer}, $data{nick}) - if $data{_bar_name} eq 'nicklist'; - mouse_evt_barcode([+{ name => $data{_bar_name} }], - undef, - '#', - $data{_bar_item_name} ne $data{_bar_name}, - $data{_bar_item_name} ? $data{_bar_item_line} : undef); + my %data = %{$_[2]}; + W->na(b => $data{_buffer}); + return mouse_nicklist_barcode(undef, + undef, + '#', + $data{_buffer}, $data{nick}) + if $data{_bar_name} eq 'nicklist'; + mouse_evt_barcode(undef, + undef, + '#', + $data{_bar_item_name} ne $data{_bar_name}, + $data{_bar_item_name} ? $data{_bar_item_line} : undef, + undef, + $data{_bar_name}); } ## SUB_MENU -- return sub menu items sub SUB_MENU { - my $active_main_menu = (MAIN_MENU())[$ACT_MENU{'main'}]; - my @menu_entries = Nlib::i2h('option', '', 'menu.var.*'); - my ($main_menu_id) = - map { $_->{'option_name'} =~ /^(\d+)[.]/ && $1 } - grep { $_->{'option_name'} =~ /^\d+[.]name$/ && $_->{'value'} eq $active_main_menu } - @menu_entries; - map { $_->{'value'} } - grep { $_->{'option_name'} =~ /^$main_menu_id[.]\d+[.]name$/ } - @menu_entries - #('Connect to &server', 'Open new &window', '&Close window', '&Leave WeeChat') + my $active_main_menu = (MAIN_MENU())[$ACT_MENU{main}]; + my @menu_entries = W->_infolist('option', '', 'menu.var.*'); + my ($main_menu_id) = + map { $_->{option_name} =~ /^(\d+)[.]/ && $1 } + grep { $_->{option_name} =~ /^\d+[.]name$/ && $_->{value} eq $active_main_menu } + @menu_entries; + map { $_->{value} } + grep { $_->{option_name} =~ /^$main_menu_id[.]\d+[.]name$/ } + @menu_entries } ## WINDOW_POPUP_MENU -- return popup menu items sub WINDOW_POPUP_MENU { - return () unless $POPUP_MENU; - map { $_->{'value'} } - grep { $_->{'option_name'} =~ /^\Q$POPUP_MENU\E[.]\d+[.]name$/ } - Nlib::i2h('option', '', "menu.var.$POPUP_MENU.*") + return () unless $POPUP_MENU; + map { $_->{value} } + grep { $_->{option_name} =~ /^\Q$POPUP_MENU\E[.]\d+[.]name$/ } + W->_infolist('option', '', "menu.var.$POPUP_MENU.*") } ## exec_submenu -- run command of active sub menu item sub exec_submenu { - my $active_main_menu = (MAIN_MENU())[$ACT_MENU{'main'}]; - my $active_sub_menu = (SUB_MENU())[$ACT_MENU{'sub'}]; - my @menu_entries = Nlib::i2h('option', '', 'menu.var.*'); - my ($main_menu_id) = - map { $_->{'option_name'} =~ /^(\d+)[.]/ && $1 } - grep { $_->{'option_name'} =~ /^\d+[.]name$/ && $_->{'value'} eq $active_main_menu } - @menu_entries; - my ($sub_menu_id) = - map { $_->{'option_name'} =~ /^\d+[.](\d+)[.]/ && $1 } - grep { $_->{'option_name'} =~ /^$main_menu_id[.]\d+[.]name$/ && $_->{'value'} eq $active_sub_menu } - @menu_entries; - my ($command) = - map { $_->{'value'} } - grep { $_->{'option_name'} =~ /^$main_menu_id[.]$sub_menu_id[.]command$/ } - @menu_entries; - local $MENU_OPEN; - weechat::command(weechat::current_buffer(), $command) if $command + my $active_main_menu = (MAIN_MENU())[$ACT_MENU{main}]; + my $active_sub_menu = (SUB_MENU())[$ACT_MENU{sub}]; + my @menu_entries = W->_infolist('option', '', 'menu.var.*'); + my ($main_menu_id) = + map { $_->{option_name} =~ /^(\d+)[.]/ && $1 } + grep { $_->{option_name} =~ /^\d+[.]name$/ && $_->{value} eq $active_main_menu } + @menu_entries; + my ($sub_menu_id) = + map { $_->{option_name} =~ /^\d+[.](\d+)[.]/ && $1 } + grep { $_->{option_name} =~ /^$main_menu_id[.]\d+[.]name$/ && $_->{value} eq $active_sub_menu } + @menu_entries; + my ($command) = + map { $_->{value} } + grep { $_->{option_name} =~ /^$main_menu_id[.]$sub_menu_id[.]command$/ } + @menu_entries; + local $MENU_OPEN; + W->current_buffer()->command($command) if $command } ## exec_popupmenu -- run command of active popup menu item sub exec_popupmenu { - my $active_popup_entry = (WINDOW_POPUP_MENU())[$ACT_MENU{'window_popup'}]; - my @menu_entries = Nlib::i2h('option', '', "menu.var.$POPUP_MENU.*"); + my $active_popup_entry = (WINDOW_POPUP_MENU())[$ACT_MENU{window_popup}]; + my @menu_entries = W->_infolist('option', '', "menu.var.$POPUP_MENU.*"); my ($popup_entry_id) = - map { $_->{'option_name'} =~ /^\Q$POPUP_MENU\E[.](\d+)[.]/ && $1 } - grep { $_->{'option_name'} =~ /^\Q$POPUP_MENU\E[.]\d+[.]name$/ && $_->{'value'} eq $active_popup_entry } + map { $_->{option_name} =~ /^\Q$POPUP_MENU\E[.](\d+)[.]/ && $1 } + grep { $_->{option_name} =~ /^\Q$POPUP_MENU\E[.]\d+[.]name$/ && $_->{value} eq $active_popup_entry } @menu_entries; my ($command) = - map { $_->{'value'} } - grep { $_->{'option_name'} =~ /^\Q$POPUP_MENU\E[.]$popup_entry_id[.]command$/ } + map { $_->{value} } + grep { $_->{option_name} =~ /^\Q$POPUP_MENU\E[.]$popup_entry_id[.]command$/ } @menu_entries; $command =~ s/\$(\d)/$POPUP_MENU_ARGS->[$1]/g if $command; local $MENU_OPEN; - weechat::command($POPUP_MENU_BUFFER, $command) if $command + W->command($POPUP_MENU_BUFFER, $command) if $command } ## bar_item_sub_menu -- return sub menu as bar items sub bar_item_sub_menu { - my @items = SUB_MENU(); - my $active_main_menu = (MAIN_MENU())[$ACT_MENU{'main'}]; - $active_main_menu =~ y/&//d; - make_menu(\@items, \$ACT_MENU{'sub'}, '==>', '', $active_main_menu); + my @items = SUB_MENU(); + my $active_main_menu = (MAIN_MENU())[$ACT_MENU{main}]; + $active_main_menu =~ y/&//d; + make_menu(\@items, \$ACT_MENU{sub}, '==>', '', $active_main_menu); } ## bar_item_window_popup_menu -- return popup menu as bar items sub bar_item_window_popup_menu { - my @items = WINDOW_POPUP_MENU(); - my $title = $POPUP_MENU_ARGS && @$POPUP_MENU_ARGS ? $POPUP_MENU_ARGS->[0] : ''; - make_menu(\@items, \$ACT_MENU{'window_popup'}, '==>', '', $title); + my @items = WINDOW_POPUP_MENU(); + my $title = $POPUP_MENU_ARGS && @$POPUP_MENU_ARGS ? $POPUP_MENU_ARGS->[0] : ''; + make_menu(\@items, \$ACT_MENU{window_popup}, '==>', '', $title); } ## bar_item_menu_help -- return help bar for menu operation sub bar_item_menu_help { - return '' unless $MENU_OPEN; - join "\n", - 'Use the arrow '.($MENU_OPEN > 1 ? 'up/down' : 'left/right').' keys or highlighted shortcuts to '. - 'select a menu entry,', - 'C-x to close menu', - 'C-h to toggle the help window', - 'RET to open' + return '' unless $MENU_OPEN; + join "\n", ( + 'Use the arrow '.($MENU_OPEN > 1 ? 'up/down' : 'left/right').' keys or highlighted shortcuts to '. + 'select a menu entry,', + 'C-x to close menu', + 'C-h to toggle the help window', + 'RET to open') } ## close_menu -- close main menu sub close_menu { - my $last_open_menu = $MENU_OPEN; - $MENU_OPEN = undef; - weechat::bar_set(weechat::bar_search('menu_help'), 'hidden', 1); - weechat::bar_set(weechat::bar_search('main_menu'), 'hidden', 1) if weechat::config_is_set_plugin('main_menu_hidden') && Nlib::has_true_value(weechat::config_get_plugin('main_menu_hidden')); - update_main_menu(); - if ($last_open_menu && $last_open_menu == 3 && $POPUP_MENU eq 'nick') { - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * x+$LAST_NICKLIST_RESCROLL_X") if $LAST_NICKLIST_RESCROLL_X; - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * y+$LAST_NICKLIST_RESCROLL_Y") if $LAST_NICKLIST_RESCROLL_Y; - ($LAST_NICKLIST_RESCROLL_X, $LAST_NICKLIST_RESCROLL_Y) = (0, 0); - } - Nlib::unhook_dynamic('1200|/input *', 'menu_input_run'); - Nlib::unhook_dynamic('input_text_content', 'menu_input_text'); - Nlib::unhook_dynamic('input_text_display_with_cursor', 'menu_input_text_display'); + my $last_open_menu = $MENU_OPEN; + $MENU_OPEN = undef; + W->bar_search('menu_help')->{hidden} = 1; + W->bar_search('main_menu')->{hidden} = 1 + if W->config_is_set_plugin('main_menu_hidden') && bool_value(W->config_get_plugin('main_menu_hidden')); + update_main_menu(); + Nlib::unhook_dynamic('1200|/input *', 'menu_input_run'); + Nlib::unhook_dynamic('input_text_content', 'menu_input_text'); + Nlib::unhook_dynamic('input_text_display_with_cursor', 'menu_input_text_display'); + W->bar_item_update('input_text'); } - ## close_window_popup_menu -- close popup menu and clean up after feature extensions (nicklist) sub close_window_popup_menu { - weechat::bar_set(weechat::bar_search('window_popup_menu'), 'hidden', 1); - $ACT_MENU{'window_popup'} = undef; - if ($LAST_NICK_COLOR && $POPUP_MENU eq 'nick') { - weechat::nicklist_nick_set(@$LAST_NICK_COLOR); - $LAST_NICK_COLOR = undef - } + W->bar_search('window_popup_menu')->{hidden} = 1; + $ACT_MENU{window_popup} = undef; + if ($LAST_NICK_COLOR && $POPUP_MENU eq 'nick') { + W->nicklist_nick_set(@$LAST_NICK_COLOR); + $LAST_NICK_COLOR = undef + } } sub expand_dynamic_menus { - my (@menu_entries, $key); - if ($MENU_OPEN == 2) { - my $active_main_menu = (MAIN_MENU())[$ACT_MENU{'main'}]; - @menu_entries = Nlib::i2h('option', '', 'menu.var.*'); - my ($main_menu_id) = - map { $_->{'option_name'} =~ /^(\d+)[.]/ && $1 } - grep { $_->{'option_name'} =~ /^\d+[.]name$/ && $_->{'value'} eq $active_main_menu } + my (@menu_entries, $key); + if ($MENU_OPEN == 2) { + my $active_main_menu = (MAIN_MENU())[$ACT_MENU{main}]; + @menu_entries = W->_infolist('option', '', 'menu.var.*'); + my ($main_menu_id) = + map { $_->{option_name} =~ /^(\d+)[.]/ && $1 } + grep { $_->{option_name} =~ /^\d+[.]name$/ && $_->{value} eq $active_main_menu } @menu_entries; - $key = $main_menu_id; - } - elsif ($MENU_OPEN == 3) { - @menu_entries = Nlib::i2h('option', '', "menu.var.$POPUP_MENU.*"); - $key = quotemeta $POPUP_MENU; - } - my %opt_table; - for (map { [ $_->{'option_name'}, $_->{'value'} ] } - grep { $_->{'option_name'} =~ /^$key[.]\d+[.](?:name|command)$/ } - @menu_entries) { - my ($pfx, $dig, $t) = $_->[0] =~ /^(.*)[.](\d+)[.](name|command)$/; - $opt_table{$dig}{$t} = [ $pfx, $_->[1] ]; - } - for my $dig (sort keys %opt_table) { - next if exists $opt_table{$dig}{'name'}; - next unless $opt_table{$dig}{'command'}[1] =~ /^%/; - my $pfx = $opt_table{$dig}{'command'}[0]; - my $raw = $dig . '090'; - weechat::command('', "/mute /unset menu.var.$pfx.$raw*"); - # %gui_buffers.buffer<50% ${buffer.number} ${buffer.name} % /buffer ${buffer.number} - my (undef, $hdata, $name, $command) = split /\s?%\s?/, $opt_table{$dig}{'command'}[1]; - my $limit; - ($hdata, $limit) = split / 0+$i); - weechat::command('', "/mute /set menu.var.$pfx.$raw$i.name @{[weechat::string_eval_expression($name, \%pointer, \%vars)]}"); - weechat::command('', "/mute /set menu.var.$pfx.$raw$i.command @{[weechat::string_eval_expression($command, \%pointer, \%vars)]}"); - @hdata = Nlib::hdh(@hdata, '!var_next'); - last if defined $limit && $i >= $limit; - } + $key = $main_menu_id; + } + elsif ($MENU_OPEN == 3) { + @menu_entries = W->_infolist('option', '', "menu.var.$POPUP_MENU.*"); + $key = quotemeta $POPUP_MENU; + } + my %opt_table; + for (map { [ $_->{option_name}, $_->{value} ] } + grep { $_->{option_name} =~ /^$key[.]\d+[.](?:name|command)$/ } + @menu_entries) { + my ($pfx, $dig, $t) = $_->[0] =~ /^(.*)[.](\d+)[.](name|command)$/; + $opt_table{$dig}{$t} = [ $pfx, $_->[1] ]; + } + for my $dig (sort keys %opt_table) { + next if exists $opt_table{$dig}{name}; + next unless $opt_table{$dig}{command}[1] =~ /^%/; + my $pfx = $opt_table{$dig}{command}[0]; + my $raw = $dig . '090'; + W->command('', "/mute /unset menu.var.$pfx.$raw*"); + # %#info_hashtable + # %gui_buffers.buffer<50% ${buffer.number} ${buffer.name} % /buffer ${buffer.number} + my (undef, $hdata, $name, $command) = split /\s?%\s?/, $opt_table{$dig}{command}[1], 4; + my $limit; + ($hdata, $limit) = split /info_get_hashtable($hdata, +{ name => $name, command => $command }); + for my $k (sort keys %$r) { + next unless $k =~ /^(\d+)[.](?:name|command)$/; + W->command('', "/mute /set menu.var.$pfx.$raw$k ${$r}{$k}"); + } + + next; ### + } + + my ($list, $hd, @path) = split '[.]', $hdata; + my $hdh = W->hdata_get($hd)->{$list} if $hd; + while ($hdh && @path) { + $hdh = $hdh->{ +shift @path }; + } + my @a = (undef, 1..9, 0, 'a'..'z'); + my $i = 0; + while ($hdh) { + $i = sprintf '%04d', $i + 1; + my %pointer = ($$hdh->{ns}[-1] => $hdh); + my %vars = (i => 0+$i, a => ($i < @a ? $a[$i] : ' ')); + W->command('', "/mute /set menu.var.$pfx.$raw$i.name @{[wee_eval($name, \%pointer, \%vars)]}"); + W->command('', "/mute /set menu.var.$pfx.$raw$i.command @{[wee_eval($command, \%pointer, \%vars)]}"); + $hdh = $hdh->_next; + last if defined $limit && $i >= $limit; } + } } ## open_menu -- open main menu or close main and sub menu if already open @@ -1377,288 +1603,291 @@ ## $_[1] - buffer ## $_[2] - arguments sub open_menu { - if ($_[2] && $_[2] eq 'reset') { - initial_menus(1); - return weechat::WEECHAT_RC_OK; - } - elsif ($_[2] && $_[2] =~ /^\s*help\s*$/i) { - Nlib::read_manpage(SCRIPT_FILE, SCRIPT_NAME); - return weechat::WEECHAT_RC_OK - } - my @args; - @args = split ' ', $_[2] - if $_[2]; - if ($MENU_OPEN && !@args) { - close_window_popup_menu() if $MENU_OPEN == 3; - close_submenu() if $MENU_OPEN == 2; - close_menu(); - return weechat::WEECHAT_RC_OK; - } - Nlib::hook_dynamic('command_run', '1200|/input *', 'menu_input_run', ''); - Nlib::hook_dynamic('modifier', 'input_text_content', 'menu_input_text', ''); - Nlib::hook_dynamic('modifier', 'input_text_display_with_cursor', 'menu_input_text_display', ''); - unless (@args) { - $MENU_OPEN = 1; - weechat::bar_set(weechat::bar_search('main_menu'), 'hidden', 0); - } - elsif ($args[0]) { - my @menu_entries = Nlib::i2h('option', '', "menu.var.$args[0].*"); - if ($args[0] eq 'nick' && !@menu_entries && $LAST_NICK_COLOR) { - weechat::nicklist_nick_set(@$LAST_NICK_COLOR); - $LAST_NICK_COLOR = undef - } - return weechat::WEECHAT_RC_OK - unless @menu_entries; - $POPUP_MENU_BUFFER = $_[1]; - $POPUP_MENU = $args[0]; - $POPUP_MENU_ARGS = [ @args[1..$#args] ]; - close_submenu() if $MENU_OPEN && $MENU_OPEN == 2; - $MENU_OPEN = 3; - expand_dynamic_menus(); - $ACT_MENU{'window_popup'} = 0; - weechat::bar_set(weechat::bar_search('window_popup_menu'), 'hidden', 0); - update_window_popup_menu(); - } - weechat::bar_set(weechat::bar_search('menu_help'), 'hidden', 0) if !weechat::config_is_set_plugin('active_help') || Nlib::has_true_value(weechat::config_get_plugin('active_help')); - update_main_menu(); - update_menu_help(); - if (@args && $args[0] eq 'nick' && $POPUP_MENU eq 'nick') { - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * x+$NICKLIST_RESCROLL_X") if $NICKLIST_RESCROLL_X; - weechat::command(weechat::current_buffer(), "/bar scroll nicklist * y+$NICKLIST_RESCROLL_Y") if $NICKLIST_RESCROLL_Y; - ($LAST_NICKLIST_RESCROLL_X, $LAST_NICKLIST_RESCROLL_Y) = - ($NICKLIST_RESCROLL_X, $NICKLIST_RESCROLL_Y); - ($NICKLIST_RESCROLL_Y, $NICKLIST_RESCROLL_X) = (0, 0); - } - weechat::WEECHAT_RC_OK + if ($_[2] && $_[2] eq 'reset') { + initial_menus(1); + return WC->RC_OK; + } + elsif ($_[2] && $_[2] =~ /^\s*help\s*$/i) { + Nlib::read_manpage($SCRIPT_FILE, SCRIPT_NAME); + return WC->RC_OK + } + my @args; + @args = split ' ', $_[2] + if $_[2]; + if ($MENU_OPEN && !@args) { + close_window_popup_menu() if $MENU_OPEN == 3; + close_submenu() if $MENU_OPEN == 2; + close_menu(); + return WC->RC_OK; + } + Nlib::hook_dynamic('command_run', '1200|/input *', 'menu_input_run', ''); + Nlib::hook_dynamic('modifier', 'input_text_content', 'menu_input_text', ''); + Nlib::hook_dynamic('modifier', 'input_text_display_with_cursor', 'menu_input_text_display', ''); + unless (@args) { + $MENU_OPEN = 1; + W->bar_search('main_menu')->{hidden} = 0; + } + elsif ($args[0]) { + my @menu_entries = W->_infolist('option', '', "menu.var.$args[0].*"); + if ($args[0] eq 'nick' && !@menu_entries && $LAST_NICK_COLOR) { + W->nicklist_nick_set(@$LAST_NICK_COLOR); + $LAST_NICK_COLOR = undef + } + return WC->RC_OK + unless @menu_entries; + $POPUP_MENU_BUFFER = $_[1]; + $POPUP_MENU = $args[0]; + $POPUP_MENU_ARGS = [ @args[1..$#args] ]; + close_submenu() if $MENU_OPEN && $MENU_OPEN == 2; + $MENU_OPEN = 3; + expand_dynamic_menus(); + $ACT_MENU{window_popup} = 0; + W->bar_search('window_popup_menu')->{hidden} = 0; + update_window_popup_menu(); + } + W->bar_search('menu_help')->{hidden} = 0 + if !W->config_is_set_plugin('active_help') || bool_value(W->config_get_plugin('active_help')); + update_main_menu(); + update_menu_help(); + WC->RC_OK } ## close_submenu -- close sub menu (does not reset $MENU_OPEN counter) sub close_submenu { - $ACT_MENU{'sub'} = undef; - my $bar = weechat::bar_search('sub_menu'); - weechat::bar_set($bar, 'hidden', 1); - weechat::bar_set($bar, 'separator', 1); - update_menu_help(); - weechat::WEECHAT_RC_OK + $ACT_MENU{sub} = undef; + my $bar = W->bar_search('sub_menu'); + $bar->{hidden} = 1; + $bar->{separator} = 1; + update_menu_help(); + WC->RC_OK } ## open_submenu -- open sub menu (does not reset $MENU_OPEN counter) sub open_submenu { - expand_dynamic_menus(); - $ACT_MENU{'sub'} = 0; - my $bar = weechat::bar_search('sub_menu'); - weechat::bar_set($bar, 'hidden', 0); - weechat::bar_set($bar, 'separator', 0) unless (Nlib::i2h('bar', weechat::bar_search('menu_help')))[0]{'hidden'}; - update_sub_menu(); - update_menu_help(); - weechat::WEECHAT_RC_OK + expand_dynamic_menus(); + $ACT_MENU{sub} = 0; + my $bar = W->bar_search('sub_menu'); + $bar->{hidden} = 0; + $bar->{separator} = 0 unless W->bar_search('menu_help')->_infolist->{hidden}; + update_sub_menu(); + update_menu_help(); + WC->RC_OK } ## setup_menu_bar -- create bars with bar menu items sub setup_menu_bar { - if (my $bar = weechat::bar_search('main_menu')) { - weechat::bar_set($bar, 'hidden', 0); - weechat::bar_set($bar, 'items', '*,main_menu') unless (Nlib::i2h('bar', $bar))[0]{'items'} =~ /\bmain_menu\b/; - } - else { - weechat::bar_new('main_menu', 'off', 10000, 'root', '', 'top', 'horizontal', 'vertical', 0, 0, 'gray', 'lightblue', 'darkgray', 'off', '*,main_menu'); - } - if (my $bar = weechat::bar_search('sub_menu')) { - weechat::bar_set($bar, 'hidden', 1); - weechat::bar_set($bar, 'items', '*sub_menu') unless (Nlib::i2h('bar', $bar))[0]{'items'} =~ /\bsub_menu\b/; - } - else { - weechat::bar_new('sub_menu', 'on', 9999, 'root', '', 'top', 'columns_vertical', 'vertical', 0, 0, 'black', 'lightmagenta', 'gray', 'on', '*sub_menu'); - } - if (my $bar = weechat::bar_search('menu_help')) { - weechat::bar_set($bar, 'hidden', 1); - weechat::bar_set($bar, 'items', 'menu_help') unless (Nlib::i2h('bar', $bar))[0]{'items'} =~ /\bmenu_help\b/; - } - else { - weechat::bar_new('menu_help', 'on', 9998, 'root', '', 'top', 'horizontal', 'vertical', 0, 0, 'darkgray', 'default', 'gray', 'on', 'menu_help'); - } - - if (my $bar = weechat::bar_search('window_popup_menu')) { - weechat::bar_set($bar, 'hidden', 1); - weechat::bar_set($bar, 'items', '*window_popup_menu') unless (Nlib::i2h('bar', $bar))[0]{'items'} =~ /\bwindow_popup_menu\b/; - } - else { - weechat::bar_new('window_popup_menu', 'on', 0, 'window', 'active', 'bottom', 'columns_vertical', 'vertical', 0, 0, 'black', 'lightmagenta', 'gray', 'on', '*window_popup_menu'); - } + if (my $bar = W->bar_search('main_menu')) { + $bar->{hidden} = 0; + $bar->{items} = '*,main_menu' unless $bar->_infolist->{items} =~ /\bmain_menu\b/; + } + else { + W->bar_new('main_menu', 'off', 10000, 'root', '', 'top', 'horizontal', 'vertical', + 0, 0, 'gray', 'lightblue', 'darkgray', 'off', '*,main_menu'); + } + if (my $bar = W->bar_search('sub_menu')) { + $bar->{hidden} = 1; + $bar->{items} = '*sub_menu' unless $bar->_infolist->{items} =~ /\bsub_menu\b/; + } + else { + W->bar_new('sub_menu', 'on', 9999, 'root', '', 'top', 'columns_vertical', 'vertical', + 0, 0, 'black', 'lightmagenta', 'gray', 'on', '*sub_menu'); + } + if (my $bar = W->bar_search('menu_help')) { + $bar->{hidden} = 1; + $bar->{items} = 'menu_help' unless $bar->_infolist->{items} =~ /\bmenu_help\b/; + } + else { + W->bar_new('menu_help', 'on', 9998, 'root', '', 'top', 'horizontal', 'vertical', + 0, 0, 'darkgray', 'default', 'gray', 'on', 'menu_help'); + } + + if (my $bar = W->bar_search('window_popup_menu')) { + $bar->{hidden} = 1; + $bar->{items} = '*window_popup_menu' unless $bar->_infolist->{items} =~ /\bwindow_popup_menu\b/; + } + else { + W->bar_new('window_popup_menu', 'on', 0, 'window', 'active', 'bottom', 'columns_vertical', 'vertical', + 0, 0, 'black', 'lightmagenta', 'gray', 'on', '*window_popup_menu'); + } - weechat::WEECHAT_RC_OK + WC->RC_OK } ## invalidate_popup_buffer -- delete popup buffer ptr if buffer is closed ## () - signal handler ## $bufptr - signal comes with pointer of closed buffer sub invalidate_popup_buffer { - my (undef, undef, $bufptr) = @_; - $POPUP_MENU_BUFFER = weechat::current_buffer() - if $bufptr eq $POPUP_MENU_BUFFER; - weechat::WEECHAT_RC_OK + my (undef, undef, $bufptr) = @_; + $POPUP_MENU_BUFFER = W->current_buffer() + if $bufptr eq $POPUP_MENU_BUFFER; + WC->RC_OK } ## config_create_opt -- create config option callback ## () - callback handler ## $_[3] - option name sub config_create_opt { - return weechat::WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND unless - $_[3] =~ /^(?:\w+[.])?\d+[.](?:name|command)$/; - weechat::config_new_option(@_[1..$#_-1], 'string', '', '', 0, 0, '', $_[-1], 0, '', '', '', '', '', ''); - weechat::WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE + return WC->CONFIG_OPTION_SET_OPTION_NOT_FOUND unless + $_[3] =~ /^(?:\w+[.])?\d+[.](?:name|command)$/; + W->config_new_option(@_[1..$#_-1], 'string', '', '', 0, 0, '', $_[-1], 0, '', '', '', '', '', ''); + WC->CONFIG_OPTION_SET_OK_SAME_VALUE } ## load_config -- create and read menu config file sub load_config { - $CFG_FILE = weechat::config_new(SCRIPT_NAME, '', ''); - $CFG_FILE_SECTION = weechat::config_new_section($CFG_FILE, 'var', 1, 1, '', '', '', '', '', '', 'config_create_opt', '', '', ''); - weechat::config_read($CFG_FILE); - weechat::WEECHAT_RC_OK + $CFG_FILE = W->config_new(SCRIPT_NAME, '', ''); + $CFG_FILE_SECTION = $CFG_FILE->new_section('var', 1, 1, '', '', '', '', '', '', 'config_create_opt', '', '', ''); + $CFG_FILE->read; + WC->RC_OK } ## hide_menu_bar -- hide all the menu bars sub hide_menu_bar { - setup_menu_bar(); - weechat::bar_set(weechat::bar_search('main_menu'), 'hidden', 1); - weechat::bar_set(weechat::bar_search('sub_menu'), 'hidden', 1); - weechat::bar_set(weechat::bar_search('menu_help'), 'hidden', 1); - weechat::bar_set(weechat::bar_search('window_popup_menu'), 'hidden', 1); - weechat::WEECHAT_RC_OK + setup_menu_bar(); + W->bar_search('main_menu')->{hidden} = 1; + W->bar_search('sub_menu')->{hidden} = 1; + W->bar_search('menu_help')->{hidden} = 1; + W->bar_search('window_popup_menu')->{hidden} = 1; + WC->RC_OK } ## update_sub_menu -- update sub menu bar item sub update_sub_menu { - weechat::bar_item_update('sub_menu'); - #weechat::bar_update('sub_menu'); - weechat::WEECHAT_RC_OK + W->bar_item_update('sub_menu'); + WC->RC_OK } ## update_main_menu -- update main menu bar item sub update_main_menu { - weechat::bar_item_update('main_menu'); - #weechat::bar_update('sub_menu'); - weechat::WEECHAT_RC_OK + W->bar_item_update('main_menu'); + WC->RC_OK } ## update_menu_help -- update menu help bar item sub update_menu_help { - weechat::bar_item_update('menu_help'); - weechat::WEECHAT_RC_OK + W->bar_item_update('menu_help'); + WC->RC_OK } ## update_window_popup_menu -- update window popup menu bar item sub update_window_popup_menu { - weechat::bar_item_update('window_popup_menu'); - weechat::WEECHAT_RC_OK + W->bar_item_update('window_popup_menu'); + WC->RC_OK } ## script_config -- check config in plugin namespace sub script_config { - weechat::bar_set(weechat::bar_search('main_menu'), 'hidden', (!$MENU_OPEN || $MENU_OPEN > 2) && weechat::config_is_set_plugin('main_menu_hidden') && Nlib::has_true_value(weechat::config_get_plugin('main_menu_hidden')) ? 1 : 0); - weechat::WEECHAT_RC_OK + W->bar_search('main_menu')->{hidden} = 0 + ((!$MENU_OPEN || $MENU_OPEN > 2) + && W->config_is_set_plugin('main_menu_hidden') && bool_value(W->config_get_plugin('main_menu_hidden'))); + update_main_menu() if (!$MENU_OPEN || $MENU_OPEN > 2); + WC->RC_OK } ## menu_config -- what is to do on updates in menu option sub menu_config { - update_window_popup_menu(); - update_sub_menu(); - update_main_menu(); - weechat::WEECHAT_RC_OK + update_window_popup_menu(); + update_sub_menu(); + update_main_menu(); + WC->RC_OK } +## $_[0] - reset all menus to default sub initial_menus { - weechat::command('', '/mute /unset menu.var.*') if $_[0]; - my @menu_entries = Nlib::i2h('option', '', 'menu.var.*'); - return if @menu_entries; - my %initial_menu = ( - '1.1.command' => '/close', - '1.1.name' => '&Close buffer', - '1.2.command' => '/quit', - '1.2.name' => '&Quit WeeChat', - '1.name' => '&File', - '2.1.command' => '/window splith', - '2.1.name' => 'Split &horizontally', - '2.2.command' => '/window splitv', - '2.2.name' => 'Split &vertically', - '2.3.command' => '/window zoom', - '2.3.name' => '&Maximize / Restore', - '2.4.command' => '/window merge', - '2.4.name' => '&Close the other window', - '2.5.command' => '/window merge all', - '2.5.name' => 'Close &all other windows', - '2.name' => '&Window', - '3.1.command' => '/xfer', - '3.1.name' => 'Transfer &list', - '3.name' => '&DCC', - '4.1.command' => '/copywin', - '4.1.name' => '&Copy window', - '4.2.command' => '/copywin /', - '4.2.name' => '&URL highlight window', - '4.3.command' => '/coords_shell', - '4.3.name' => '&Perl debug shell', - '4.4.command' => '/iset', - '4.4.name' => '&Settings editor', - '4.name' => '&Tools', - '5.1.command' => '%irc_servers.irc_server% ${irc_server.name} % /connect ${irc_server.name}', - '5.name' => '&Connect', - '6.1.command' => '%gui_buffers.buffer% ${i} ${buffer.name} % /buffer ${buffer.full_name}', - '6.name' => '&Buffers', - '7.1.command' => '%gui_windows.window% ${window.number} ${window.buffer.name} % /window ${window.number}', - '7.name' => 'Win&list', - '9.1.name' => 'Menu system by Nei', - '9.2.name' => '&Help', - '9.2.command' => '/menu help', - '9.name' => '&About', - 'nick.1.command' => '/query $0', - 'nick.1.name' => '&Query', - 'nick.2.command' => '/wii $0', - 'nick.2.name' => '&Whois', - 'nick.3.command' => '/op $0', - 'nick.3.name' => '&Op', - 'nick.4.command' => '/voice $0', - 'nick.4.name' => '&Voice', - 'nick.5.command' => '/kick $0', - 'nick.5.name' => '&Kick', - 'nick.6.command' => '/ban $0', - 'nick.6.name' => '&Ban', - 'buffer1.1.command' => '/buffer close', - 'buffer1.1.name' => '&Close', - 'buffer1.2.command' => '/buffer clear', - 'buffer1.2.name' => 'Clea&r', - 'buffer1.3.command' => '/buffer unmerge', - 'buffer1.3.name' => '&Unmerge', - 'buffer1.4.command' => '/buffer notify none', - 'buffer1.4.name' => '&Ignore', - 'buffer1.5.command' => '/buffer notify reset', - 'buffer1.5.name' => 'U&nignore', - 'buffer2.1.command' => '/buffer close $1-$2', - 'buffer2.1.name' => '&Close range', - 'buffer2.2.command' => '/buffer swap $1 $2', - 'buffer2.2.name' => '&Swap', - 'buffer2.3.command' => '/buffer merge $2', - 'buffer2.3.name' => '&Merge', - ); - weechat::config_new_option($CFG_FILE, $CFG_FILE_SECTION, $_, 'string', '', '', 0, 0, '', $initial_menu{$_}, 0, '', '', '', '', '', '') for sort keys %initial_menu; - #weechat::command('', '/key bind meta2-P /menu'); + W->command('', '/mute /unset menu.var.*') if $_[0]; + my @menu_entries = W->_infolist('option', '', 'menu.var.*'); + return if @menu_entries; + my %initial_menu = ( + '1.1.command' => '/close', + '1.1.name' => '&Close buffer', + '1.2.command' => '/quit', + '1.2.name' => '&Quit WeeChat', + '1.name' => '&File', + '2.1.command' => '/window splith', + '2.1.name' => 'Split &horizontally', + '2.2.command' => '/window splitv', + '2.2.name' => 'Split &vertically', + '2.3.command' => '/window zoom', + '2.3.name' => '&Maximize / Restore', + '2.4.command' => '/window merge', + '2.4.name' => '&Close the other window', + '2.5.command' => '/window merge all', + '2.5.name' => 'Close &all other windows', + '2.name' => '&Window', + '3.1.command' => '/xfer', + '3.1.name' => 'Transfer &list', + '3.name' => '&DCC', + '4.1.command' => '/copywin', + '4.1.name' => '&Copy window', + '4.2.command' => '/copywin /', + '4.2.name' => '&URL highlight window', + '4.3.command' => '/coords_shell', + '4.3.name' => '&Perl debug shell', + '4.4.command' => '/iset', + '4.4.name' => '&Settings editor', + '4.name' => '&Tools', + '5.1.command' => '%irc_servers.irc_server% ${irc_server.name} % /connect ${irc_server.name}', + '5.name' => '&Connect', + '6.1.command' => '%gui_buffers.buffer% ${i} ${buffer.name} % /buffer ${buffer.full_name}', + '6.name' => '&Buffers', + '7.1.command' => '%gui_windows.window% ${window.number} ${window.buffer.name} % /window ${window.number}', + '7.name' => 'Win&list', + '9.1.name' => 'Menu system by Nei', + '9.2.name' => '&Help', + '9.2.command' => '/menu help', + '9.name' => '&About', + 'nick.1.command' => '/query $0', + 'nick.1.name' => '&Query', + 'nick.2.command' => '/wii $0', + 'nick.2.name' => '&Whois', + 'nick.3.command' => '/op $0', + 'nick.3.name' => '&Op', + 'nick.4.command' => '/voice $0', + 'nick.4.name' => '&Voice', + 'nick.5.command' => '/kick $0', + 'nick.5.name' => '&Kick', + 'nick.6.command' => '/ban $0', + 'nick.6.name' => '&Ban', + 'buffer1.1.command' => '/buffer close', + 'buffer1.1.name' => '&Close', + 'buffer1.2.command' => '/buffer clear', + 'buffer1.2.name' => 'Clea&r', + 'buffer1.3.command' => '/buffer unmerge', + 'buffer1.3.name' => '&Unmerge', + 'buffer1.4.command' => '/buffer notify none', + 'buffer1.4.name' => '&Ignore', + 'buffer1.5.command' => '/buffer notify reset', + 'buffer1.5.name' => 'U&nignore', + 'buffer2.1.command' => '/buffer close $1-$2', + 'buffer2.1.name' => '&Close range', + 'buffer2.2.command' => '/buffer swap $1 $2', + 'buffer2.2.name' => '&Swap', + 'buffer2.3.command' => '/buffer merge $2', + 'buffer2.3.name' => '&Merge', + ); + $CFG_FILE->new_option($CFG_FILE_SECTION, $_, 'string', '', '', + 0, 0, '', $initial_menu{$_}, 0, '', '', '', '', '', '') + for sort keys %initial_menu; } sub init_menu { - $ACT_MENU{'main'} = 0; - $POPUP_MENU_BUFFER = weechat::current_buffer(); - load_config(); - initial_menus(); - setup_menu_bar(); - script_config(); - update_main_menu(); - weechat::WEECHAT_RC_OK + $ACT_MENU{main} = 0; + $POPUP_MENU_BUFFER = W->current_buffer(); + load_config(); + initial_menus(); + setup_menu_bar(); + script_config(); + for (Nlib::get_settings_from_pod($SCRIPT_FILE)) { + W->config_set_desc_plugin($_, Nlib::get_desc_from_pod($SCRIPT_FILE, $_)); + } + update_main_menu(); + WC->RC_OK } sub stop_menu { - hide_menu_bar(); - weechat::config_write($CFG_FILE); - weechat::config_section_free_options($CFG_FILE_SECTION); - weechat::config_section_free($CFG_FILE_SECTION); - weechat::config_free($CFG_FILE); - weechat::WEECHAT_RC_OK + hide_menu_bar(); + $CFG_FILE->write; + $CFG_FILE_SECTION->free_options; + $CFG_FILE_SECTION->free; + $CFG_FILE->free; + WC->RC_OK } diff -Nru weechat-scripts-20130123/perl/multiline.pl weechat-scripts-20131007/perl/multiline.pl --- weechat-scripts-20130123/perl/multiline.pl 2013-01-23 19:00:27.000000000 +0000 +++ weechat-scripts-20131007/perl/multiline.pl 2013-10-07 12:14:58.000000000 +0000 @@ -120,7 +120,7 @@ =cut use constant SCRIPT_NAME => 'multiline'; -weechat::register(SCRIPT_NAME, 'Nei ', '0.4', 'GPL3', 'Multi-line edit box', 'stop_multiline', '') || return; +weechat::register(SCRIPT_NAME, 'Nei ', '0.6', 'GPL3', 'Multi-line edit box', 'stop_multiline', '') || return; sub SCRIPT_FILE() { my $infolistptr = weechat::infolist_get('perl_script', '', SCRIPT_NAME); my $filename = weechat::infolist_string($infolistptr, 'filename') if weechat::infolist_next($infolistptr); @@ -185,10 +185,6 @@ } $$target = $r; - my $code = qq{ - local \$[=1; - \$list{"\Q$key\E"}$idx = \$r - }; $key => $list{$key} } else { @@ -202,6 +198,11 @@ } ## hdh -- hdata helper +## $_[0] - arg pointer or hdata list name +## $_[1] - hdata name +## $_[2..$#_] - hdata variable name +## $_[-1] - hashref with key/value to update (optional) +## returns value of hdata, and hdata name in list ctx, or number of variables updated sub hdh { if (@_ > 1 && $_[0] !~ /^0x/ && $_[0] !~ /^\d+$/) { my $arg = shift; @@ -210,18 +211,22 @@ while (@_ > 2) { my ($arg, $name, $var) = splice @_, 0, 3; my $hdata = weechat::hdata_get($name); + unless (ref $var eq 'HASH') { + $var =~ s/!(.*)/weechat::hdata_get_string($hdata, $1)/e; + (my $plain_var = $var) =~ s/^\d+\|//; + my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); + if ($type eq 'pointer') { + my $name = weechat::hdata_get_var_hdata($hdata, $var); + unshift @_, $name if $name; + } - $var =~ s/!(.*)/weechat::hdata_get_string($hdata, $1)/e; - (my $plain_var = $var) =~ s/^\d+\|//; - my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); - if ($type eq 'pointer') { - my $name = weechat::hdata_get_var_hdata($hdata, $var); - unshift @_, $name if $name; + my $fn = "weechat::hdata_$type"; + unshift @_, do { no strict 'refs'; + &$fn($hdata, $arg, $var) }; + } + else { + return weechat::hdata_update($hdata, $arg, $var); } - - my $fn = "weechat::hdata_$type"; - unshift @_, do { no strict 'refs'; - &$fn($hdata, $arg, $var) }; } wantarray ? @_ : $_[0] } @@ -259,7 +264,7 @@ exists \$DYNAMIC_HOOKS{\$what}{\$sub}; delete \$DYNAMIC_HOOKS{\$what}{\$sub}; delete \$DYNAMIC_HOOKS{\$what} unless \%{\$DYNAMIC_HOOKS{\$what}}; - }; + }; die $@ if $@; } @@ -304,6 +309,8 @@ } ## mangle_man_for_wee -- turn man output into weechat codes +## @_ - list of grotty lines that should be turned into weechat attributes +## returns modified lines and modifies lines in-place sub mangle_man_for_wee { for (@_) { s/_\x08(.)/weechat::color('underline').$1.weechat::color('-underline')/ge; @@ -337,6 +344,7 @@ my $width = $wininfo->{'chat_width'}; --$width if $wininfo->{'chat_width'} < $wininfo->{'width'} || ($wininfo->{'width_pct'} < 100 && (grep { $_->{'y'} == $wininfo->{'y'} } Nlib::i2h('window'))[-1]{'x'} > $wininfo->{'x'}); + $width -= 2; # when prefix is shown weechat::buffer_set($buf, 'time_for_each_line', 0); eval qq{ @@ -369,7 +377,7 @@ weechat::buffer_set($buf, 'key_bind_q', '/buffer close'); - weechat::print($buf, " \t".mangle_man_for_wee($_)) + weechat::print($buf, " \t".mangle_man_for_wee($_)) # weird bug with \t\t showing nothing? for `pod2man \Q$file\E 2>/dev/null | GROFF_NO_SGR=1 nroff -mandoc -rLL=${width}n -rLT=${width}n -Tutf8 2>/dev/null`; weechat::command($buf, '/window scroll_top'); @@ -410,8 +418,10 @@ weechat::hook_command_run(INPUT_MAGIC, 'magic_enter', ''); Nlib::hook_dynamic('signal', 'input_text_*', 'magic_enter_cancel', ''); weechat::hook_signal('key_pressed', 'magic_lock_hatch', ''); -weechat::hook_signal('500|input_text_changed', 'paste_undo_hack', ''); # we need lower than default priority here or the first character is separated -weechat::hook_command_run('/input *', 'paste_undo_start_ignore', ''); +# we need lower than default priority here or the first character is separated +weechat::hook_signal('500|input_text_changed', 'paste_undo_hack', '') + # can only do this on weechat 0.4.0 + if (weechat::info_get('version_number', '') || 0) >= 0x00040000; hook_complete('complete*', 'delete_*', 'move_*'); ## multiline_display -- show multi-lines on display of input string @@ -471,6 +481,7 @@ return paste_undo_stop_ignore() if $IGNORE_INPUT_CHANGED2; if ($MAGIC_LOCK > 0 && get_lock_enabled()) { signall_ignore_input_changed(1); + Nlib::hook_dynamic('command_run', '/input *', 'paste_undo_start_ignore', ''); Encode::_utf8_on(my $input = weechat::buffer_get_string($_[2], 'input')); my $pos = weechat::buffer_get_integer($_[2], 'input_pos'); @@ -480,6 +491,7 @@ weechat::buffer_set($_[2], 'input', $input); weechat::buffer_set($_[2], 'input_pos', $pos); + Nlib::unhook_dynamic('/input *', 'paste_undo_start_ignore'); signall_ignore_input_changed(0); } weechat::WEECHAT_RC_OK @@ -499,8 +511,10 @@ weechat::hook_signal_send('input_flow_free', weechat::WEECHAT_HOOK_SIGNAL_INT, 1); Nlib::hook_dynamic('signal', '2000|input_text_changed', 'input_changed_eater', ''); $IGNORE_INPUT_CHANGED = 1; + weechat::buffer_set('', 'completion_freeze', '1'); } else { + weechat::buffer_set('', 'completion_freeze', '0'); $IGNORE_INPUT_CHANGED = undef; Nlib::unhook_dynamic('2000|input_text_changed', 'input_changed_eater'); weechat::hook_signal_send('input_flow_free', weechat::WEECHAT_HOOK_SIGNAL_INT, 0); diff -Nru weechat-scripts-20130123/perl/notify_send.pl weechat-scripts-20131007/perl/notify_send.pl --- weechat-scripts-20130123/perl/notify_send.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/notify_send.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,127 @@ +# WeeChat pm and highlight notifications via notify-send +# +# modelled after 'WeeChat ubus notifications' by Arvid Picciani +# +# license: GPL3 +# contact: shmibs@gmail.com +# history: +# 1.4 another small bug-fix +# 1.3 a small fix to formatting $message +# 1.2 use config options +# 1.1 restructured code for (greater) sanity +# 1.0 first working version + +use strict; +use warnings; +use constant SCRIPT_NAME => 'notify_send'; + +weechat::register(SCRIPT_NAME, 'shmibs', '1.4', 'GPL3', 'execute a user-defined system command upon highlight or private message (with smart delays to avoid spam)', '', ''); + +# global var declarations +my %pv_times; +my %highlight_times; +my %settings_default=( + 'wait_pm' => [ '180', 'necessary time delay between private messages (seconds) for command to be executed' ], + 'wait_highlight' => [ '60', 'necessary time delay between highlights (seconds) for command to be executed' ], + 'ignore_nicks' => [ '', 'comma-separated list of nicks to ignore' ], + 'command' => [ 'notify-send $type: $name', 'system command to be executed ($type, $name, and $message will be interpreted as values)' ] +); +my %settings=(); + +#------------------------------------[ START CONFIGURATION ]------------------------------------ + +sub config_changed { + my ($pointer, $name, $value) = @_; + $name = substr($name, length("plugins.var.perl.".SCRIPT_NAME."."), length($name)); + $settings{$name} = $value; + return weechat::WEECHAT_RC_OK; +} + +sub config_init{ + my $version = weechat::info_get("version_number", "") || 0; + foreach my $option (keys %settings_default) { + if (!weechat::config_is_set_plugin($option)) { + weechat::config_set_plugin($option, $settings_default{$option}[0]); + $settings{$option} = $settings_default{$option}[0]; + } else { + $settings{$option} = weechat::config_get_plugin($option); + } + if ($version >= 0x00030500) { + weechat::config_set_desc_plugin($option, $settings_default{$option}[1]." (default: \"".$settings_default{$option}[0]."\")"); + } + } +} + +config_init(); +weechat::hook_config("plugins.var.perl.".SCRIPT_NAME.".*", "config_changed", ""); + +#-------------------------------------[ END CONFIGURATION ]------------------------------------- + +my @signals=qw(weechat_pv weechat_highlight); + +# message received hook +foreach(@signals) { + weechat::hook_signal($_,'new_notification',''); +} + +sub new_notification { + # $_[1] is the type (either weechat_highlight, weechat_pv) + # $_[2] is the actual content + + # get the username and message contents + my $name=substr($_[2],0,index($_[2],' ')); + my $message=substr($_[2],index($_[2],' ')); + if($name eq ' *'){ + $name=substr($_[2],index($_[2],' *')+3); + $message=substr($name,index($name,' ')); + $name=substr($name,0,index($name,' ')); + } + $message =~ s/ //; + $name =~ s/@|\+//; + + # get the type of the message + my $type; + if($_[1] eq 'weechat_pv') { + $type='PM'; + } else { + $type='HL'; + } + + # boolean to determine whether or not a notification should + # be sent + my $send='true'; + + # ignore messages from nicks in ignore_nicks option + foreach(split(/,/,$settings{'ignore_nicks'})) { + $send='false' if($name eq $_); + } + + # determine whether a notification of the same type has been + # made recently. if so, ignore it + if($type eq 'PM'){ + if(exists $pv_times{$name}) { + if(time-$pv_times{$name} < int($settings{'wait_pm'})) { + $send='false'; + } + } + $pv_times{$name} = time; + } else { + if(exists $highlight_times{$name}) { + if(time-$highlight_times{$name} < int($settings{'wait_highlight'})) { + $send='false'; + } + } + $highlight_times{$name} = time; + } + + # run system command + if($send eq 'true') { + my ($command,$args) = split(/ /,$settings{'command'},2); + $args =~ s/\$type/$type/g; + $args =~ s/\$name/$name/g; + $args =~ s/\$message/$message/g; + system($command, $args); + } + + return weechat::WEECHAT_RC_OK; +} diff -Nru weechat-scripts-20130123/perl/parse_relayed_msg.pl weechat-scripts-20131007/perl/parse_relayed_msg.pl --- weechat-scripts-20130123/perl/parse_relayed_msg.pl 2013-01-23 19:00:27.000000000 +0000 +++ weechat-scripts-20131007/perl/parse_relayed_msg.pl 2013-10-07 12:14:58.000000000 +0000 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011-2012 by w8rabbit (w8rabbit[at]mail[dot]i2p) +# Copyright (c) 2011-2013 by w8rabbit (w8rabbit[at]mail[dot]i2p) # or from outside i2p: w8rabbit[at]i2pmail[dot]org # # Script is under GPL3. @@ -8,6 +8,8 @@ # # thanks to darrob for hard beta-testing # +# 1.7: add support of colors with format "${color:xxx}" (>= WeeChat 0.4.2) +# 1.6: add wildcard "*" for supported_bot_names. # 1.5: cleaned up code and make it more readable # 1.4: fix: problem with tag "prefix_nick_ccc" # improved: Nicks will be displayed the same way in Nicklist like in channel buffer. @@ -58,16 +60,16 @@ use strict; my $SCRIPT_NAME = "parse_relayed_msg"; -my $SCRIPT_VERSION = "1.5"; +my $SCRIPT_VERSION = "1.7"; my $SCRIPT_DESCR = "proper integration of remote users' nicknames in channel and nicklist"; my $SCRIPT_AUTHOR = "w8rabbit"; my $SCRIPT_LICENCE = "GPL3"; # =============== options =============== -my %option = ( "supported_bot_names" => "uuu,u2,i2pRelay,iRelay,MultiRelay,FLIPRelayBot,fox,wolf,hawk,muninn,gribble,vulpine", +my %option = ( "supported_bot_names" => "cloudrelay*,MultiRelay*,FLIPRelayBot*,i2pRelay,u2,uuu,RelayBot,lll,iRelay,fox,wolf,hawk,muninn,gribble,vulpine", "debug" => "off", "blacklist" => "", - "servername" => "i2p", + "servername" => "i2p,freenet", "nick_mode" => "⇅", "nick_mode_color" => "yellow", "suppress_relaynet" => "off", @@ -81,9 +83,9 @@ my %script_desc = ( "blacklist" => "Comma-separated list of relayed nicknames to be ignored (similar to /ignore). The format is case-sensitive: .", "supported_bot_names" => "Comma-separated list of relay bots.", "debug" => "Enable output of raw IRC messages. This is a developer feature and should generally be turned off. The format is: : (default: off)", - "servername" => "Comma-separated list of internal servers to enable $SCRIPT_NAME for. (default: i2p)", - "nick_mode" => "Prefix character used to mark relayed nicknames. (default: ⇅)", - "nick_mode_color" => "Color of the prefix character. (default: yellow)", + "servername" => "Comma-separated list of internal servers to enable $SCRIPT_NAME for. (default: i2p,freenet)", + "nick_mode" => "Prefix character used to mark relayed nicknames. (default: ⇅). Since WeeChat 0.4.2 you can use format \${color:xxx}, eg: \${color:yellow}⇅", + "nick_mode_color" => "Color of the prefix character. (default: yellow). This option is obsolet since WeeChat 0.4.2 (see option nick_mode)", "suppress_relaynet" => "Hide nicknames' network part (if applicable). (default: off)", "suppress_relaynet_channels" => "Comma-separated list of channels to activate suppress_relaynet in. Format: \"servername.channel\", e.g. \"i2p.#i2p-dev,freenode.#weechat\". (default: \"\" (i.e. global))", "relaynet_color" => "Color of nicknames' network part. Leave blank for altering colors. (default: \"\")", @@ -139,7 +141,9 @@ $nick = $2; # display_mode : 0 = /, 1 = @ - if ( grep /^$nick$/, @bot_nicks ) # does a bot exists? + my $result = string_mask_to_regex($nick); + if ($result) +# if ( grep /^$nick$/, @bot_nicks ) # does a bot exists? { my $blacklist_raw = weechat::config_get_plugin("blacklist"); @blacklist = split( /,/,$blacklist_raw); @@ -302,8 +306,7 @@ return $string; } my $nick_color = weechat::info_get('irc_nick_color', $relaynick);# get nick-color - $string = weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + $string = _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $nick_mode . $nick_color . $relaynick . @@ -326,8 +329,7 @@ if ( $option{suppress_relaynet} eq "on" and $option{suppress_relaynet_channels} eq "" or ( grep /^$servername.$channelname$/, @suppress_relaynet_channels) ){ # suppress relaynet - $string = weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + $string = _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $nick_mode . $nick_color . $relaynick . @@ -337,8 +339,7 @@ { # show relaynet my $relay_and_nick = relay_and_nick($relaynet,$relaynick,$display_mode); - $string = weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + $string = _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $nick_mode . $relay_and_nick. "\t" . @@ -360,12 +361,10 @@ my $nick_color = weechat::info_get('irc_nick_color', $relaynick);# get nick-color my $prefix_action = weechat::config_string(weechat::config_get("weechat.look.prefix_action")); my $prefix_color = weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_prefix_action"))); - $string = $prefix_color . - $prefix_action . + $string = _color_str($prefix_color, $prefix_action) . $nick_mode . "\t" . - weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $nick_color . $relaynick . weechat::color("default") . @@ -388,13 +387,12 @@ my $prefix_action = weechat::config_string(weechat::config_get("weechat.look.prefix_action")); my $prefix_color = weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_prefix_action"))); - if ( $option{suppress_relaynet} eq "on" and $option{suppress_relaynet_channels} eq "" or ( grep /^$servername.$channelname$/, @suppress_relaynet_channels) ){ - $string = $prefix_color . - $prefix_action . + if ( $option{suppress_relaynet} eq "on" and $option{suppress_relaynet_channels} eq "" or ( grep /^$servername.$channelname$/, @suppress_relaynet_channels) ) + { + $string = _color_str($prefix_color, $prefix_action) . $nick_mode . "\t" . - weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $nick_color . $relaynick . weechat::color("default") . @@ -404,12 +402,10 @@ { # show relaynet my $relay_and_nick = relay_and_nick($relaynet,$relaynick,$display_mode); - $string = $prefix_color . - $prefix_action . + $string = _color_str($prefix_color, $prefix_action) . $nick_mode . "\t" . - weechat::color($option{nick_mode_color}) . - $option{nick_mode} . + _color_str( $option{nick_mode_color}, $option{nick_mode} ) . $relay_and_nick . weechat::color("default") . " " . @@ -445,10 +441,10 @@ } } - my $prefix_action = weechat::config_string(weechat::config_get("weechat.look.prefix_error")); + my $prefix_error = weechat::config_string(weechat::config_get("weechat.look.prefix_error")); my $prefix_color = weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_prefix_error"))); - $string = $prefix_color . - $prefix_action . + + $string = _color_str($prefix_color, $prefix_error) . "\t" . "wrecked message from: ". $relay_and_nick; @@ -589,7 +585,9 @@ # add nick to nicklist, if my $group exists if ( $ptr_nick_gui eq "" ) { - weechat::nicklist_add_nick($buf_ptr,$ptr_group,$relaynick,$nick_color,$option{nick_mode},$option{nick_mode_color},1); + my $test = weechat::string_remove_color( _color_str($option{nick_mode_color},$option{nick_mode}),"" ); + weechat::nicklist_add_nick($buf_ptr,$ptr_group,$relaynick,$nick_color,$test,$option{nick_mode_color},1); +# weechat::nicklist_add_nick($buf_ptr,$ptr_group,$relaynick,$nick_color,$option{nick_mode},$option{nick_mode_color},1); weechat::nicklist_nick_set($buf_ptr,$ptr_nick_gui,"prefix",$option{nick_mode}); weechat::nicklist_nick_set($buf_ptr,$ptr_nick_gui,"prefix_color",$option{nick_mode_color}); } @@ -618,6 +616,14 @@ } } } +sub _color_str +{ + my ($color_name, $string) = @_; + # use eval for colors-codes (${color:red} eg in weechat.look.prefix_error) + $string = weechat::string_eval_expression($string, {}, {},{}) if ($weechat_version >= 0x00040200); + return weechat::color($color_name) . $string . weechat::color('reset'); +} + # =============== config =============== sub init_config { @@ -744,6 +750,20 @@ return weechat::WEECHAT_RC_OK; } +# ========= string_mask_to_regex() ========= +sub string_mask_to_regex +{ + my ($nick) = @_; + foreach ( @bot_nicks ){ + my $bot_nick = weechat::string_mask_to_regex($_); + if ($nick =~ /^$bot_nick$/i) + { + return 1; + } + } + return 0; +} + # ========= colorize_lines ========= sub colorize_lines { diff -Nru weechat-scripts-20130123/perl/pop3_mail.pl weechat-scripts-20131007/perl/pop3_mail.pl --- weechat-scripts-20130123/perl/pop3_mail.pl 2013-01-23 19:00:24.000000000 +0000 +++ weechat-scripts-20131007/perl/pop3_mail.pl 2013-10-07 12:14:56.000000000 +0000 @@ -1,7 +1,7 @@ # -# Copyright (c) 2010 by Nils Görs +# Copyright (c) 2010-2013 by Nils Görs # -# checks POP3 server for mails and display mail headers +# checks POP3 server for mails and display mail headers # # 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 @@ -19,9 +19,21 @@ # Config: # Add [mail] to your weechat.bar.status.items # +# +# 2013-09-15: nils_2 (freenode.#weechat) +# 0.3 : add: option prefix_item +# +# 2013-07-29: nils_2 (freenode.#weechat) +# 0.2 : support of /secure for passwords +# : added: %h variable for filename +# # 0.1: initial version +# # Thanks to Trashlord for the hint with hook_process() # +# Development is currently hosted at +# https://github.com/weechatter/weechat-scripts +# # This script needs following perl modules: # Tie::IxHash # Mail::POP3Client @@ -44,32 +56,33 @@ use Crypt::Rijndael; use Encode; -#"✉" -my $prgname = "pop3_mail"; -my $version = "0.1"; -my $description = "check POP3 server for mails and display mail header"; -my $item_name = "mail"; +my $prgname = "pop3_mail"; +my $SCRIPT_version = "0.3"; +my $description = "check POP3 server for mails and display mail header"; +my $item_name = "mail"; # -------------------------------[ config ]------------------------------------- -my $default_pop3list = "pop3list.txt"; -my %default_options = ("refresh" => "10", # interval in minutes to check pop3 accounts - "pop3_timeout" => "20", # timeout for pop3_server (in seconds) - "show_header" => "From|Subject", - "passphrase" => "enter passphrase", - "delete_passphrase_on_exit" => "on", - ); +my $default_pop3list = "%h/pop3list.txt"; +my %default_options = ("refresh" => "10", # interval in minutes to check pop3 accounts + "pop3_timeout" => "20", # timeout for pop3_server (in seconds) + "show_header" => "From|Subject", + "passphrase" => "enter passphrase", + "delete_passphrase_on_exit" => "on", + "prefix_item" => "✉:", + ); # ------------------------------[ internal ]----------------------------------- -my %Hooks = (); # space for my hooks -my %mailcount = (); # how many mails for all accounts and in how many accounts? -my $bar_item = ""; -my $filename = (); +my %Hooks = (); # space for my hooks +my %mailcount = (); # how many mails for all accounts and in how many accounts? +my $bar_item = ""; +my $filename = (); +my $weechat_version = ""; # -------------------------------[ hook_process() command ]------------------------------------- # arguments: user, password, server, port, timeout, (no)header -if ($#ARGV == 5 ) { # six arguments given? +if ($#ARGV == 5 ) { # six arguments given? my $user = $ARGV[0]; my $password = $ARGV[1]; my $pop3server = $ARGV[2]; @@ -82,7 +95,7 @@ } else { $use_ssl = 0; } - my $pop3 = new Mail::POP3Client( + my $pop3 = new Mail::POP3Client( #DEBUG => 1, USER => $user, PASSWORD => $password, @@ -140,16 +153,19 @@ weechat::config_set_plugin("refresh", "0") unless hook_timer(); # fall back to '0', if hook fails } } - }elsif ($option eq $plugin_name."pop3_timeout"){ - $default_options{pop3_timeout} = $value; - }elsif ($option eq $plugin_name."show_header"){ - $default_options{show_header} = $value; - }elsif ($option eq $plugin_name."passphrase"){ - return weechat::WEECHAT_RC_OK if (check_passphrase_length($value) eq 1); - $default_options{passphrase} = $value; - }elsif ($option eq $plugin_name."delete_passphrase_on_exit"){ - $default_options{delete_passphrase_on_exit} = $value; - } + }elsif ($option eq $plugin_name."prefix_item"){ + $default_options{prefix_item} = my_eval_expression($value); + weechat::bar_item_update($item_name); + }elsif ($option eq $plugin_name."pop3_timeout"){ + $default_options{pop3_timeout} = $value; + }elsif ($option eq $plugin_name."show_header"){ + $default_options{show_header} = $value; + }elsif ($option eq $plugin_name."passphrase"){ + $default_options{passphrase} = my_eval_expression($value); + return weechat::WEECHAT_RC_OK if (check_passphrase_length($default_options{passphrase}) eq 1); + }elsif ($option eq $plugin_name."delete_passphrase_on_exit"){ + $default_options{delete_passphrase_on_exit} = $value; + } return weechat::WEECHAT_RC_OK; } @@ -242,7 +258,7 @@ my ( $cmd, $arg ) = ( $getargs =~ /(.*?)\s+(.*?)/ ); return weechat::WEECHAT_RC_OK if (not defined $cmd); - + if ($cmd eq "list" and defined $arg){ ( $cmd, $arg ) = ( $getargs =~ /(.*?)\s+(\d.*)/ ); @@ -305,36 +321,39 @@ return weechat::WEECHAT_RC_OK; } -sub init{ - if ( weechat::config_get_plugin("pop3_list") eq "" ) { - my $wd = weechat::info_get( "weechat_dir", "" ); - $wd =~ s/\/$//; - weechat::config_set_plugin("pop3_list", $wd . "/" . $default_pop3list ); - } - read_file(); - -# get absolute path of script - my $infolist_pnt = weechat::infolist_get("perl_script","",$prgname); - weechat::infolist_next($infolist_pnt); - $filename = weechat::infolist_string($infolist_pnt,"filename"); - weechat::infolist_free($infolist_pnt); +sub init +{ + weechat::config_set_plugin("pop3_list", $default_pop3list ) if ( weechat::config_get_plugin("pop3_list") eq "" ); + read_file(); + + # get absolute path of script + my $infolist_pnt = weechat::infolist_get("perl_script","",$prgname); + weechat::infolist_next($infolist_pnt); + $filename = weechat::infolist_string($infolist_pnt,"filename"); + weechat::infolist_free($infolist_pnt); #set default config -foreach my $option (keys %default_options) { - if ( !weechat::config_is_set_plugin($option) ) { +foreach my $option (keys %default_options) +{ + if ( !weechat::config_is_set_plugin($option) ) + { weechat::config_set_plugin($option, $default_options{$option}); - }else { - $default_options{$option} = weechat::config_get_plugin($option); + }else + { + $default_options{$option} = weechat::config_get_plugin($option); } } + $default_options{passphrase} = my_eval_expression($default_options{passphrase}); + $default_options{prefix_item} = my_eval_expression($default_options{prefix_item}); + return if (check_passphrase_length($default_options{passphrase}) eq 1); } sub show_mail { if ( (keys %pop3_accounts) == 1 ){ - return sprintf ("✉: %d", $mailcount{mails_over_all}); + return sprintf ("$default_options{prefix_item} %d", $mailcount{mails_over_all}); }else{ - return sprintf ("✉: %d (%d)", $mailcount{mails_over_all}, $mailcount{accounts_with_mails}); + return sprintf ("$default_options{prefix_item} %d (%d)", $mailcount{mails_over_all}, $mailcount{accounts_with_mails}); } } @@ -439,7 +458,7 @@ if(length($plaintext) % 16 != 0 ) { - $plaintext .= ' ' x (16 - (length($plaintext) % 16)); } + $plaintext .= ' ' x (16 - (length($plaintext) % 16)); } my $rencrypted = $rcipher->encrypt($plaintext); # encrypt $base64 = encode_base64($rencrypted); # base64 it @@ -455,53 +474,86 @@ $base64 = decode_base64($base64); # if(length($plaintext) % 16 != 0 ) { -# $plaintext .= ' ' x (16 - (length($plaintext) % 16)); } +# $plaintext .= ' ' x (16 - (length($plaintext) % 16)); } my $rencrypted = $rcipher->decrypt($base64); $rencrypted =~ s/\s+\z//; # remove space from end of string return $rencrypted; } -sub check_passphrase_length{ - my ( $passphrase ) = @_; - my $len = length($passphrase); - if (! ($len == 16) or ($len == 24) or ($len == 32) ){ - weechat::print("",weechat::prefix("error")."$prgname: wrong key length: passphrase must be 128, 192 or 256 bits long"); - return 1; #false - } +sub check_passphrase_length +{ + my ( $passphrase ) = @_; + my $len = length($passphrase); + if (! ($len == 16) or ($len == 24) or ($len == 32) ) + { + weechat::print("",weechat::prefix("error")."$prgname: wrong key length: passphrase must be 128, 192 or 256 bits long"); + return 1; #false + } return 0; #true } +sub my_eval_expression +{ + my $value = $_[0]; + if ( ($weechat_version ne "") && ($weechat_version >= 0x00040200) ) + { + my $eval_expression = weechat::string_eval_expression($value,{},{},{}); + return $eval_expression if ($eval_expression ne ""); + } +return $value; +} + + # -------------------------------[ load, save, shutdown, debug routine ]------------------------------------- -sub save_file { - my $x = keys %pop3_accounts; - if ($x ne 0){ # entries in pop3_accounts? - my $pop3list = weechat::config_get_plugin( "pop3_list" ); - open (WL, ">", $pop3list) || DEBUG("write pop3_list: $!"); - while ( my($user,$passwort) = each %pop3_accounts) { - print WL "$user $passwort\n"; - } - close WL; - }else{ - my $pop3list = weechat::config_get_plugin( "pop3_list" ); - unlink($pop3list); - } +sub save_file +{ + my $x = keys %pop3_accounts; + if ($x ne 0) # messages in pop3_accounts? + { + my $pop3list = weechat_dir(); + open (WL, ">", $pop3list) || DEBUG("write pop3_list: $!"); + while ( my($user,$passwort) = each %pop3_accounts) + { + print WL "$user $passwort\n"; + } + close WL; + } + else + { + my $pop3list = weechat_dir(); + unlink($pop3list); + } } -sub read_file { - my $pop3list = weechat::config_get_plugin("pop3_list"); - return unless -e $pop3list; - open (WL, "<", $pop3list) || DEBUG("$pop3list: $!"); - while () { - chomp; # kill LF - my ( $user, $password ) = split / /; # - if (not defined $user){ - close WL; - weechat::print("",weechat::prefix("error")."$prgname: $pop3list is not valid..."); - return; - } - $pop3_accounts{$user} = $password if length $_; - } - close WL; +sub read_file +{ + my $pop3list = weechat_dir(); + return unless -e $pop3list; + open (WL, "<", $pop3list) || DEBUG("$pop3list: $!"); + while () + { + chomp; # kill LF + my ( $user, $password ) = split / /; # + if (not defined $user) + { + close WL; + weechat::print("",weechat::prefix("error")."$prgname: $pop3list is not valid..."); + return; + } + $pop3_accounts{$user} = $password if length $_; + } + close WL; +} + +sub weechat_dir +{ + my $dir = weechat::config_get_plugin("pop3_list"); + if ( $dir =~ /%h/ ) + { + my $weechat_dir = weechat::info_get( 'weechat_dir', ''); + $dir =~ s/%h/$weechat_dir/; + } + return $dir; } sub shutdown{ @@ -524,43 +576,47 @@ sub DEBUG {weechat::print('', "***\t" . $_[0]);} # first function called by a WeeChat-script. -weechat::register($prgname, "Nils Görs ", $version, +weechat::register($prgname, "Nils Görs ", $SCRIPT_version, "GPL3", $description, "shutdown", ""); +$weechat_version = weechat::info_get("version_number", ""); init(); $Hooks{config} = weechat::hook_config( "plugins.var.perl.$prgname.*", "toggled_by_set", "" ); $Hooks{command} = weechat::hook_command($prgname, $description, - "[list ] | [add user(\@host) server:port password] | [del number] | check", + "[list ] | [add user(\@host) server:port password] | [del number] | check", - "list : display account(s)\n". - "list : display mail header(s) for specified account\n". - "add : add new account (template: )\n". - "del : delete an account\n". - "check : check POP3 account(s) manually\n". - "\n". - "This script is using Rijndael(AES) encryption to protect your pop3 password(s) in config file.\n". - "Keep in mind that the passphrase is not encrypted. Use /rmodifier function to hide passphrase.\n". - "\n". - "Options:\n". - "plugins.var.perl.$prgname.passphrase : to encrypt pop3 passwords in config file (default: empty)\n". - "plugins.var.perl.$prgname.pop3_list : file to store account, server and password (default: ~/.weechat/pop3list.txt)\n". - "plugins.var.perl.$prgname.pop3timeout : set a timeout value for socket operations (default: 20 seconds)\n". - "plugins.var.perl.$prgname.refresh : checks pop3 account (default: 10 minutes)\n". - "plugins.var.perl.$prgname.show_header : displays mail headers (default: From|Subject)\n". - "plugins.var.perl.$prgname.delete_passphrase_on_exit : delete passphrase on exit (default: on)\n". - "You have to edit option \"delete_passphrase_on_exit\" manually each time when weechat or script (re)starts. Switching option to \"off\" will keep passphrase in weechat-config.\n". - "\n". - "Add item [mail] to your \"weechat.bar.status.items\"\n". - "\n". - "Examples:\n". - "Add account with hostname and ssl/tls protocol to monitore:\n". - "/$prgname add myuser\@host.de pop3.server.de:995 mypassword\n". - "Add account without hostname and without ssl/tls protocol to monitore:\n". - "/$prgname add myuser pop3.server.de:110 mypassword\n". - "Delete account with number 001 from list:\n". - "/$prgname del 1\n", - "add|del|list|check", "user_cmd", ""); + "list : display account(s)\n". + "list : display mail header(s) for specified account\n". + "add : add new account (template: )\n". + "del : delete an account\n". + "check : check POP3 account(s) manually\n". + "\n". + "This script is using Rijndael(AES) encryption to protect your pop3 password(s) in config file.\n". + "Keep in mind that the passphrase is not encrypted. Use /rmodifier function to hide passphrase.\n". + "Using Weechat 0.4.2 or higher its recommended to use /secure to protect passphrase.\n". + "\n". + "Options:\n". + "plugins.var.perl.$prgname.passphrase : to encrypt pop3 passwords in config file (default: empty)\n". + " Since WeeChat 0.4.2 its possible to encrypt passphrase (see /help secure) eg: \${sec.data.pop3_passphrase}\n". + "plugins.var.perl.$prgname.pop3_list : file to store account, server and password (default: %h/pop3list.txt)\n". "plugins.var.perl.$prgname.pop3timeout : set a timeout (in seconds) for socket operations (default: 20)\n". + "plugins.var.perl.$prgname.refresh : checks pop3 account (in minutes) (default: 10)\n". + "plugins.var.perl.$prgname.show_header : displays mail headers (default: From|Subject)\n". + "plugins.var.perl.$prgname.prefix_item : displays a prefix (default: ✉:). Since WeeChat 0.4.2 you can use \${color:xxx}\n". + "plugins.var.perl.$prgname.delete_passphrase_on_exit : delete passphrase on exit (default: on)\n". + "\n". + "You have to edit option \"delete_passphrase_on_exit\" manually each time when weechat or script (re)starts. Switching option to \"off\" will keep passphrase in weechat-config.\n". + "\n". + "Add item [mail] to your \"weechat.bar.status.items\"\n". + "\n". + "Examples:\n". + "Add account with hostname and ssl/tls protocol to monitore:\n". + "/$prgname add myuser\@host.de pop3.server.de:995 mypassword\n". + "Add account without hostname and without ssl/tls protocol to monitore:\n". + "/$prgname add myuser pop3.server.de:110 mypassword\n". + "Delete account with number 001 from list:\n". + "/$prgname del 1\n", + "add|del|list|check", "user_cmd", ""); hook_timer() if ($default_options{refresh} ne "0"); diff -Nru weechat-scripts-20130123/perl/pushover.pl weechat-scripts-20131007/perl/pushover.pl --- weechat-scripts-20130123/perl/pushover.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/pushover.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,146 @@ +# +# Copyright (C) 2013 stfn +# +# 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 . +# + +# +# Development is currently hosted at +# https://github.com/stfnm/weechat-scripts +# + +use strict; +use warnings; +use CGI; + +my %SCRIPT = ( + name => 'pushover', + author => 'stfn ', + version => '0.3', + license => 'GPL3', + desc => 'Send real-time push notifications to your mobile devices using pushover.net', + opt => 'plugins.var.perl', +); +my %OPTIONS_DEFAULT = ( + 'token' => ['', 'API Token/Key'], + 'user' => ['', "User Key"], + 'sound' => ['', "Sound (empty for default)"], + 'enabled' => ['on', "Turn script on or off"], + 'show_highlights' => ['on', 'Notify on highlights'], + 'show_priv_msg' => ['on', 'Notify on private messages'], + 'only_if_away' => ['off', 'Notify only if away status is active'], + 'blacklist' => ['', 'Comma separated list of buffers to blacklist for notifications'], +); +my %OPTIONS = (); + +# Register script and setup hooks +weechat::register($SCRIPT{"name"}, $SCRIPT{"author"}, $SCRIPT{"version"}, $SCRIPT{"license"}, $SCRIPT{"desc"}, "", ""); +weechat::hook_print("", "irc_privmsg", "", 1, "print_cb", ""); +init_config(); + +# +# Handle config stuff +# +sub init_config +{ + weechat::hook_config("$SCRIPT{'opt'}.$SCRIPT{'name'}.*", "config_cb", ""); + my $version = weechat::info_get("version_number", "") || 0; + foreach my $option (keys %OPTIONS_DEFAULT) { + if (!weechat::config_is_set_plugin($option)) { + weechat::config_set_plugin($option, $OPTIONS_DEFAULT{$option}[0]); + $OPTIONS{$option} = $OPTIONS_DEFAULT{$option}[0]; + } else { + $OPTIONS{$option} = weechat::config_get_plugin($option); + } + if ($version >= 0x00030500) { + weechat::config_set_desc_plugin($option, $OPTIONS_DEFAULT{$option}[1]." (default: \"".$OPTIONS_DEFAULT{$option}[0]."\")"); + } + } +} +sub config_cb +{ + my ($pointer, $name, $value) = @_; + $name = substr($name, length("$SCRIPT{opt}.$SCRIPT{name}."), length($name)); + $OPTIONS{$name} = $value; + return weechat::WEECHAT_RC_OK; +} + +# +# Send to pushover.net +# +sub pushover +{ + my ($token, $user, $sound, $message) = @_; + + my @post = ( + "token=$token", + "user=$user", + "message=" . CGI::escape($message), + ); + push(@post, "sound=$sound") if ($sound && length($sound) > 0); + + # Send POST request + my $hash = { "post" => 1, "postfields" => join(";", @post) }; + weechat::hook_process_hashtable("url:https://api.pushover.net/1/messages.json", $hash, 20 * 1000, "", ""); + #weechat::print("", "[$SCRIPT{name}] debug: postfields -> @post, msg -> $message"); + + return weechat::WEECHAT_RC_OK; +} + +# +# Notification wrapper +# +sub notify +{ + my $msg = $_[0]; + pushover($OPTIONS{token}, $OPTIONS{user}, $OPTIONS{sound}, $msg); +} + +sub grep_array($$) +{ + my ($str, $array_ref) = @_; + my @array = @{$array_ref}; + return (grep {$_ =~ /^\Q$str\E$/i} @array) ? 1 : 0; +} + +# +# Catch printed messages +# +sub print_cb +{ + my ($data, $buffer, $date, $tags, $displayed, $highlight, $prefix, $message) = @_; + + if ($OPTIONS{enabled} ne "on") { + return weechat::WEECHAT_RC_OK; + } + + my @blacklist = split(/,/, $OPTIONS{blacklist}); + my $buffer_type = weechat::buffer_get_string($buffer, "localvar_type"); + my $buffer_name = weechat::buffer_get_string($buffer, "name"); + my $buffer_shortname = weechat::buffer_get_string($buffer, "short_name"); + my $away_msg = weechat::buffer_get_string($buffer, "localvar_away"); + my $away = ($away_msg && length($away_msg) > 0) ? 1 : 0; + + # Away or blacklisted? + if (($OPTIONS{only_if_away} eq "off" || $away) && (@blacklist == 0 || + (!grep_array($buffer_name, \@blacklist) && !grep_array($buffer_shortname, \@blacklist)))) { + # Private message or highlight? + if (($OPTIONS{show_priv_msg} eq "on" && $buffer_type eq "private") || + ($OPTIONS{show_highlights} eq "on" && $highlight == 1)) { + notify("[$buffer_shortname] <$prefix> $message"); # Send notification + } + } + + return weechat::WEECHAT_RC_OK; +} diff -Nru weechat-scripts-20130123/perl/query_blocker.pl weechat-scripts-20131007/perl/query_blocker.pl --- weechat-scripts-20130123/perl/query_blocker.pl 2013-01-23 19:00:23.000000000 +0000 +++ weechat-scripts-20131007/perl/query_blocker.pl 2013-10-07 12:14:55.000000000 +0000 @@ -3,7 +3,8 @@ # query_blocker.pl - Simple blocker for private messages (i.e. spam). # # ----------------------------------------------------------------------------- -# Copyright (c) 2009-2012 by rettub +# Copyright (c) 2009-2013 by rettub +# Copyright (c) 2011-2013 by nils_2 # # 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 @@ -32,8 +33,31 @@ # Newest version available at: # git://github.com/rettub/weechat-plugins.git # +## Development is currently hosted at +# https://github.com/weechatter/weechat-scripts +# # ----------------------------------------------------------------------------- # History: +# 2013-05-01, nils_2: +# version 0.8: +# ADD: option ignore_auto_message (suggested by bpeak) +# +# 2013-02-24, nils_2: +# version 0.7: +# FIX: case insensitive comparison for "nickserv" and "chanserv" +# ADD: option 'show_first_message_only' (suggested by gry) +# +# 2012-08-16, nils_2: +# version 0.6.1: +# IMPROVED: help text to allow a temporary query +# +# 2012-06-12, nils_2: +# version 0.6: +# FIX: allow own queries without 'mynick' in query whitelist +# ADD: option 'temporary_mode'. +# ADD: whitelist is now using format: server.nickname (please update your qb-whitelist!) +# ADD: tab completion for all commands +# # 2012-05-03, nils_2: # version 0.5: # FIX: invalid pointer for function infolist_get() @@ -61,9 +85,6 @@ # version 0.1: initial release # # ----------------------------------------------------------------------------- -# FIXME -# - add 'mynick' to list - needed? -# # TODO # - make Auto-Messages configurable @@ -73,7 +94,7 @@ my $SCRIPT = 'query_blocker'; my $AUTHOR = 'rettub '; -my $VERSION = '0.5'; +my $VERSION = '0.8'; my $LICENSE = 'GPL3'; my $DESCRIPTION = 'Simple blocker for private message (i.e. spam)'; my $COMMAND = "query_blocker"; # new command name @@ -83,6 +104,7 @@ "show_deny_message" => "show you the deny message, sent to user. (default: 'off')", "show_hint" => "show hint how to allow queries for nick. (default: 'on')", "show_nick_only" => "only show nick and server. (default: 'off')", + "show_first_message_only"=> "Show only first message sent by blocked queries (default: 'on')", "whitelist" => "path/file-name to store/read nicks not to be blocked (default: qb-whitelist.txt)", "auto_message" => "messages to inform user that you don't like to get private messages without asking first. '%N' will be replaced with users nick.", "auto_message_prefix" => "Prefix for auto message, may not be empty!", @@ -90,6 +112,8 @@ "logger" => "logger status for $SCRIPT buffer (default: 'off')", "hotlist_show" => "$SCRIPT buffer appear in hotlists (status bar/buffer.pl) (default: 'off')", "open_on_startup" => "open $SCRIPT buffer on startup. option msgbuffer has to be set to 'buffer' (default: 'off')", + "temporary_mode" => "if 'on' you have to manually add a nick to whitelist. otherwise a conversation will be temporary only and after closing query buffer the nick will be discard (default: 'off')", + "ignore_auto_message" => "path/file-name to store/read nicks to not send an auto message (default: qb-ignore_auto_message.txt)", ); my $CMD_HELP = < "off", "show_hint" => "on", "show_nick_only"=> "off", + "show_first_message_only" => "on", "whitelist" => "qb-whitelist.txt", "auto_message" => "I'm using a query blocking script, please wait while i whitelist you!", "auto_message_prefix" => "Auto-Message: ", @@ -146,9 +181,10 @@ "logger" => "off", "hotlist_show" => "off", "open_on_startup" => "off", + "temporary_mode" => "off", + "ignore_auto_message" => "qb-ignore_auto_message.txt", ); -# FIXME store server too? my $Last_query_nick = undef; sub DEBUG {weechat::print('', "***\t" . $_[0]);} @@ -165,6 +201,27 @@ my %Blocked = (); my %Allowed = (); +my %ignore_auto_message = (); + +sub check_ignore_auto_message { return exists $ignore_auto_message{ $_[0] }; } + +sub ignore_auto_message_read { + my $whitelist = weechat::config_get_plugin( "ignore_auto_message" ); + return unless -e $whitelist; + open (WL, "<", $whitelist) || DEBUG("$whitelist: $!"); + while () { + chomp; + my ( $server, $nick ) = split /\./,$_; # servername.nickname + if (not defined $nick){ + close WL; + weechat::print("",weechat::prefix("error")."$SCRIPT: $whitelist wrong format for entry: $_ (new format: servername.nickname)."); + return 1; + } + $ignore_auto_message{$_} = 1 if length $_; + } + close WL; + return 0; +} sub nick_allowed { return exists $Allowed{ $_[0] }; } @@ -174,15 +231,24 @@ open (WL, "<", $whitelist) || DEBUG("$whitelist: $!"); while () { chomp; - $Allowed{$_} = 1 if length $_; + my ( $server, $nick ) = split /\./,$_; # servername.nickname + if (not defined $nick){ + close WL; + weechat::print("",weechat::prefix("error")."$SCRIPT: $whitelist wrong format for entry: $_ (new format: servername.nickname)."); + return 1; + } + $Allowed{$_} = 1 if length $_; } close WL; + return 0; } sub whitelist_save { my $whitelist = weechat::config_get_plugin( "whitelist" ); open (WL, ">", $whitelist) || DEBUG("write whitelist: $!"); - print WL "$_\n" foreach ( sort { "\L$a" cmp "\L$b" } keys %Allowed ); + foreach ( sort { "\L$a" cmp "\L$b" } keys %Allowed ){ + print WL "$_\n" if ($Allowed{$_} == 1); + } close WL; } @@ -220,6 +286,7 @@ my ( $buffer, $server, $my_nick, $nick, $message ) = @_; my $prefix_network = weechat::config_string( weechat::config_get("weechat.look.prefix_network")); my $buf_pointer = ""; + my $orig_message = $message; if ( $buffer eq "current" ){ $buf_pointer = weechat::current_buffer(); @@ -249,23 +316,39 @@ } return $buf_pointer if (lc(weechat::config_get_plugin('quiet') eq "on")); - if (weechat::config_get_plugin('show_nick_only') eq 'off') { + if (lc(weechat::config_get_plugin('show_nick_only') eq 'off')) { $message = ": $message"; }else{ $message = ""; } - weechat::print($buf_pointer,"$prefix_network\t" - .irc_nick_find_color($nick).$nick - .weechat::color('reset') - ." tries to start a query on " - .irc_nick_find_color($server).$server - .weechat::color('reset') - .$message ); - - weechat::print($buf_pointer,"$prefix_network\t" - ."to allow query: /$COMMAND add " - .irc_nick_find_color($nick).$nick - .weechat::color('reset') ) unless (weechat::config_get_plugin('show_hint') eq 'off'); + + unless ( exists $Blocked{$server.".".$nick} and lc(weechat::config_get_plugin('show_first_message_only') eq 'off') ) { + weechat::print($buf_pointer,"$prefix_network\t" + .irc_nick_find_color($nick).$nick + .weechat::color('reset') + ." tries to start a query on " + .irc_nick_find_color($server).$server + .weechat::color('reset') + .$message ); + weechat::print($buf_pointer,"$prefix_network\t" + ."to allow query: /$COMMAND add " + .irc_nick_find_color($server).$server + .weechat::color('reset') + ."." + .irc_nick_find_color($nick).$nick + .weechat::color('reset')."\n" + ."or to allow temporary query: /query -server " + .irc_nick_find_color($server).$server + .weechat::color('reset') + ." " + .irc_nick_find_color($nick).$nick + .weechat::color('reset')) unless (weechat::config_get_plugin('show_hint') eq 'off'); + }else{ + weechat::print($buf_pointer,irc_nick_find_color($server).$server."." + .irc_nick_find_color($nick).$nick."\t" + .weechat::color('reset') + .$orig_message ); + } return $buf_pointer; } @@ -292,13 +375,21 @@ my $query_nick = $1; my $query_msg = $2; + # always allow own queries + return $arg if ($query_nick eq $my_nick); + # if nick is allowed to send queries, let WeeChat handle the query - return $arg if nick_allowed($query_nick); + return $arg if nick_allowed($server . "." . $query_nick); + + # if nick is in ignore_auto_message list, ignore it. + return '' if check_ignore_auto_message($server . "." . $query_nick); - $Last_query_nick = $query_nick; + $Last_query_nick = $server . "." . $query_nick; my $buf_pointer; - unless ( exists $Blocked{$query_nick} ) { - unless (weechat::config_get_plugin('quiet') eq 'on') { + unless ( exists $Blocked{$server.".".$query_nick} and lc(weechat::config_get_plugin('show_first_message_only') eq 'on') ) + { + unless (lc(weechat::config_get_plugin('quiet') eq 'on')) + { # print messages to.... newsbar, current, private, server, weechat, buffer, highmon if ( newsbar() eq "1" and lc(weechat::config_get_plugin('msgbuffer')) eq 'newsbar' ) { info2newsbar( 'lightred', '[QUERY-WARN]', $server, $query_nick, $query_msg ); @@ -329,15 +420,19 @@ if (lc(weechat::config_get_plugin('show_deny_message')) eq 'off' or lc(weechat::config_get_plugin('quiet') eq 'on')) { weechat::command( '', "/mute -all /msg -server $server $query_nick $msg " ); - }else + } + else { weechat::command( '', "/mute -all /msg -server $server $query_nick $msg " ); weechat::print($buf_pointer,"$SCRIPT\t"."$query_nick"."@"."$server: $msg"); } - $Blocked{$query_nick} = 0; + # counter for how many blocked messages + $Blocked{$server.".".$query_nick} = 0; } - $Blocked{$query_nick}++; - } else { + $Blocked{$server.".".$query_nick}++; + } + else + { return $arg; } @@ -345,21 +440,46 @@ return ''; } +# add nick to whitelist sub _add { my $arg = shift; + my $temporary_mode = shift; + my $temporary_txt = ""; if ( defined $arg ) { foreach ( split( / +/, $arg ) ) { - $Last_query_nick = undef if ( defined $Last_query_nick and $_ eq $Last_query_nick ); - $Allowed{$_} = 1; - delete $Blocked{$_}; - weechat::print( '', "Allow queries for: '" . irc_nick_find_color($_) . $_ . weechat::color('reset') . "'"); + my ($server,$nick); + ($server,$nick) = split(/\./,$_); + if (not defined $nick){ + $nick = $server; + $server = weechat::buffer_get_string(weechat::current_buffer(),"localvar_server"); + if ($server eq ""){ + weechat::print( '', "Server missing for: '". + irc_nick_find_color($nick). + $nick . weechat::color('reset') . "'"); + return; + } + } + $Last_query_nick = undef if ( defined $Last_query_nick and $server.".".$nick eq $Last_query_nick ); + $Allowed{$server.".".$nick} = $temporary_mode; + delete $Blocked{$server.".".$nick}; + $temporary_txt = " (temporary)" if ($temporary_mode == 2); + weechat::print( '', "Allow" . $temporary_txt ." queries for: '". + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick). + $nick . weechat::color('reset') . "'"); } whitelist_save(); } elsif ( defined $Last_query_nick and not exists $Allowed{$Last_query_nick} ) { - $Allowed{$Last_query_nick} = 1; + $Allowed{$Last_query_nick} = $temporary_mode; + my ($server,$nick) = split(/\./,$Last_query_nick); delete $Blocked{$Last_query_nick}; - weechat::print( '', "Allow queries for: '" . irc_nick_find_color($Last_query_nick) . $Last_query_nick . weechat::color('reset') . "'"); + weechat::print( '', "Allow" . $temporary_txt . " queries for: '". + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick). + $nick . weechat::color('reset') . "'"); $Last_query_nick = undef; whitelist_save(); # FIXME: open query window @@ -377,9 +497,9 @@ sub qb_hook { return 1 if qb_hooked(); - $Hooks{query} = weechat::hook_command_run( '/query *', 'qb_query', "" ); - $Hooks{msg} = weechat::hook_command_run( '/msg *', 'qb_msg', "" ); - $Hooks{modifier} = weechat::hook_modifier( "irc_in_privmsg", "modifier_irc_in_privmsg", "" ); + $Hooks{query} = weechat::hook_command_run( '/query *', 'qb_query', "" ); + $Hooks{msg} = weechat::hook_command_run( '/msg *', 'qb_msg', "" ); + $Hooks{modifier_in} = weechat::hook_modifier( "irc_in_privmsg", "modifier_irc_in_privmsg", "" ); $Hooks{completion_del} = weechat::hook_completion("perl_query_blocker_del", "query blocker completion_del", "query_blocker_completion_del_cb", ""); $Hooks{completion_add} = weechat::hook_completion("perl_query_blocker_add", "query blocker completion_add", "query_blocker_completion_add_cb", ""); @@ -388,7 +508,7 @@ DEBUG("cant hook completion for add argument") if $Hooks{completion_add} eq ''; DEBUG("cant hook command '/query'") if $Hooks{query} eq ''; DEBUG("cant hook command '/msg'") if $Hooks{msg} eq ''; - DEBUG("cant hook modifier 'irc_in_privmsg'") if $Hooks{modifier} eq ''; + DEBUG("cant hook modifier 'irc_in_privmsg'") if $Hooks{modifier_in} eq ''; return 0; } @@ -399,7 +519,7 @@ # FIXME handle hook errors (hook_ returns NULL := '') weechat::unhook( $Hooks{query} ); weechat::unhook( $Hooks{msg} ); - weechat::unhook( $Hooks{modifier} ); + weechat::unhook( $Hooks{modifier_in} ); weechat::unhook( $Hooks{completion_del} ); weechat::unhook( $Hooks{completion_add} ); undef %Hooks; @@ -469,7 +589,12 @@ if ( $cmd eq 'list' ) { if ( defined $arg and $arg eq 'last' ) { if (defined $Last_query_nick) { - weechat::print( '', "Last blocked nick: '" . irc_nick_find_color($Last_query_nick) . $Last_query_nick . weechat::color('reset') . "'"); + my ($server,$nick) = split(/\./,$Last_query_nick); + weechat::print( '', "Last blocked nick: '". + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick). + $nick . weechat::color('reset') . "'"); } else { weechat::print( '', "No blocked nicks"); } @@ -477,32 +602,56 @@ my $n = keys %Allowed; weechat::print( '', "Allowed nicks for queries ($n):" ); foreach ( sort { "\L$a" cmp "\L$b" } keys %Allowed ) { - weechat::print( '', " " . irc_nick_find_color($_) . $_ ); + my ($server,$nick) = split(/\./,$_); + my $temporary_txt = ""; + $temporary_txt = " (temporary)" if ( $Allowed{$server.".".$nick} == 2); + weechat::print( '', " ". + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick). + $nick . weechat::color('reset'). + $temporary_txt); } } } elsif ( $cmd eq 'blocked' ) { if ( keys %Blocked ) { if ( defined $arg and $arg eq 'clear' ) { + weechat::print( '', "Removing blocked state from:"); foreach ( sort { "\L$a" cmp "\L$b" } keys %Blocked ) { - weechat::print( '', "Removing blocked state from" . irc_nick_find_color($_) . $_ ); + my ($server,$nick) = split(/\./,$_); + weechat::print( '', " " . + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick) . $nick . + weechat::color('reset') . " (#$Blocked{$_})"); delete $Blocked{$_}; } } else { weechat::print( '', "Queries of this nicks have been blocked:" ); foreach ( sort { "\L$a" cmp "\L$b" } keys %Blocked ) { - weechat::print( '', " " . irc_nick_find_color($_) . $_ . weechat::color('reset') . " (#$Blocked{$_})"); + my ($server,$nick) = split(/\./,$_); + weechat::print( '', " " . + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick) . $nick . + weechat::color('reset') . " (#$Blocked{$_})"); } } } else { weechat::print( '', "No nicks have been blocked" ); } } elsif ( $cmd eq 'add' ) { - _add($arg); + _add($arg,1); }elsif ( $cmd eq 'del' and defined $arg ) { foreach ( split( / +/, $arg ) ) { if (exists $Allowed{$_} ) { delete $Allowed{$_}; - weechat::print( '', "Nick removed from whitelist: '" . irc_nick_find_color($_) . $_ . weechat::color('reset') . "'"); + my ($server,$nick) = split(/\./,$_); + weechat::print( '', "Nick removed from whitelist: '". + weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_server"))).$server . + weechat::color('reset') . "." . + irc_nick_find_color($nick) . $nick . + weechat::color('reset') . "'"); } else { weechat::print( '', "Can't remove nick, not in whitelist: '" . irc_nick_find_color($_) . $_ . weechat::color('reset') . "'"); } @@ -526,20 +675,35 @@ return $l; } +# /query sub qb_query { - my $n = _get_nick($_[2]); - _add($n) unless nick_allowed($n); + my ($data, $buffer, $command) = @_; + my $server = weechat::buffer_get_string($buffer,"localvar_server"); + return weechat::WEECHAT_RC_OK if ($server eq ""); + + my $n = _get_nick($command); + return weechat::WEECHAT_RC_OK if (lc($n) eq "nickserv" or lc($n) eq "chanserv"); + my $temporary_mode = 1; + $temporary_mode = 2 if (weechat::config_get_plugin('temporary_mode') eq "on"); + _add($server.".".$n,$temporary_mode) unless nick_allowed($server.".".$n); return weechat::WEECHAT_RC_OK; } # add nick as allowed if responce isn't auto reply sub qb_msg { - my ($msg) = $_[2] =~ /^\/msg -server .*?\s.*?\s(.*)/; + my ($data, $buffer, $command) = @_; + my $server = weechat::buffer_get_string($buffer,"localvar_server"); + return weechat::WEECHAT_RC_OK if ($server eq ""); + + my ($msg) = $command =~ /^\/msg -server .*?\s.*?\s(.*)/; my $n = _get_nick($_[2]); + return weechat::WEECHAT_RC_OK if (lc($n) eq "nickserv" or lc($n) eq "chanserv"); my $prefix = weechat::config_get_plugin('auto_message_prefix'); - _add($n) unless nick_allowed($n) or $msg =~ /^$prefix/; + my $temporary_mode = 1; + $temporary_mode = 2 if (weechat::config_get_plugin('temporary_mode') eq "on"); + _add($server.".".$n,$temporary_mode) unless nick_allowed($server.".".$n) or $msg =~ /^$prefix/; return weechat::WEECHAT_RC_OK; } @@ -570,6 +734,19 @@ return weechat::WEECHAT_RC_OK; } +sub buffer_closing_cb +{ + my ($data, $signal, $signal_data) = @_; + return weechat::WEECHAT_RC_OK if ( weechat::buffer_get_string($signal_data, "localvar_type" ne "private")); + my $name = weechat::buffer_get_string($signal_data, "localvar_name"); + foreach ( sort { "\L$a" cmp "\L$b" } keys %Allowed ) + { + my ($server,$nick) = split(/\./,$_); + delete $Allowed{$_} if ( defined $Allowed{$_} and $Allowed{$server.".".$nick} == 2 and $name eq $server.".".$nick ); + } + return weechat::WEECHAT_RC_OK; +} + # ----------------------------------------------------------------------------- # if ( weechat::register( $SCRIPT, $AUTHOR, $VERSION, $LICENSE, $DESCRIPTION, "", "" ) ) { @@ -587,9 +764,17 @@ weechat::config_set_plugin( $option, $default_value ) if weechat::config_get_plugin($option) eq ""; } - whitelist_read(); + + if ( whitelist_read() ){ + weechat::command("","/wait 1ms /perl unload $SCRIPT"); + return; + } + weechat::print( '', "$COMMAND: loaded whitelist '" . weechat::config_get_plugin( "whitelist" ) . "'"); + ignore_auto_message_read(); + + weechat::hook_signal("buffer_closing","buffer_closing_cb",""); weechat::hook_config( "plugins.var.perl.$SCRIPT.block_queries", 'toggled_by_set', $SCRIPT ); if ( ($weechat_version ne "") && (weechat::info_get("version_number", "") >= 0x00030500) ) { # v0.3.5 foreach my $option ( keys %help_desc ){ @@ -609,5 +794,3 @@ weechat::print( '', "$COMMAND: disabled"); } } - -# vim: ai ts=4 sts=4 et sw=4 tw=0 foldmethod=marker : diff -Nru weechat-scripts-20130123/perl/rssagg.pl weechat-scripts-20131007/perl/rssagg.pl --- weechat-scripts-20130123/perl/rssagg.pl 2013-01-23 19:00:27.000000000 +0000 +++ weechat-scripts-20131007/perl/rssagg.pl 2013-10-07 12:14:58.000000000 +0000 @@ -15,8 +15,8 @@ # along with this program. If not, see . # # -# rssagg, version 1.0, for weechat version 0.3.7 or later -# watch multiple RSS feeds and display the most current articles +# rssagg, version 1.1, for weechat version 0.3.7 or later +# watch multiple RSS/RDF/Atom feeds and display the most current articles # Thank you nils_2, Flashcode, Nei # # Requires Perl module XML::FeedPP @@ -40,7 +40,10 @@ # # # History: -# 2012-11-05, R1cochet : +# 2013-04-06, R1cochet : +# v1.1: Added option "rssagg.engine.autostop". Added "last" option to /rssagg command. +# Muted filter in rssagg buffer. Fixed partial feed callback. Other bug fixes. +# 2012-11-05, R1cochet : # v1.0: Initial Public Release # @@ -50,18 +53,18 @@ use XML::FeedPP; my $SCRIPT_NAME = "rssagg"; -my $VERSION = "1.0"; -my $SCRIPT_DESC = "RSS Aggregator for WeeChat"; +my $VERSION = "1.1"; +my $SCRIPT_DESC = "RSS/RDF/Atom feed aggregator for WeeChat"; ######################### Global Vars ######################### my $config_file; # config file pointer my %config = (); # config hash my @feeds; # list of feed names my %feeds = (); # feed hash +my %partial_feed = (); # for multiple url callbacks on large feeds my $rssagg_buffer = ""; # pointer to buffer my $rsslist_buffer = ""; # pointer to free buffer my $rssagg_bar = ""; # pointer to bar -my $partial_feed = ""; # for multiple url callbacks on large feeds my @buffer_lines; # buffer display lines my @bar_lines; # bar lines my @bar_lines_time; # bar line time @@ -197,6 +200,8 @@ "Automatically start a feed once added.", "", 0, 0, "off", "off", 0, "", "", "", "", "", "",); $config{'options'}{'autostart_on_load'} = weechat::config_new_option($config_file, $config{'sections'}{'engine'}, "autostart_on_load", "boolean", "Automatically start all feeds on script load.", "", 0, 0, "off", "off", 0, "", "", "", "", "", "",); + $config{'options'}{'autostop'} = weechat::config_new_option($config_file, $config{'sections'}{'engine'}, "autostop", "integer", + "Automatically stop feed after n number of fails (set to 0 to disable).", "", 0, 20, "3", "3", 0, "", "", "", "", "", "",); $config{'options'}{'default_delay'} = weechat::config_new_option($config_file, $config{'sections'}{'engine'}, "default_delay", "integer", "Set the default delay for fetching feeds (mins).", "", 10, 240, "60", "60", 0, "", "", "", "", "", "",); $config{'options'}{'max_headlines'} = weechat::config_new_option($config_file, $config{'sections'}{'engine'}, "max_headlines", "integer", @@ -728,14 +733,14 @@ if ($commands[0] eq "f") { my $filter = infolist_filter(); if ($filter eq "rssagg") { - weechat::command("", "/filter del rssagg"); + weechat::command("", "/mute /filter del rssagg"); } if ($commands[1]) { if (weechat::config_string($config{'options'}{'filter_mode'}) eq "reverse") { $commands[1] = "!".$commands[1]; $commands[1] =~ s/,/,!/g; } - weechat::command("", "/filter add rssagg perl.rssagg * $commands[1]"); + weechat::command("", "/mute /filter add rssagg perl.rssagg * $commands[1]"); } set_buffer_title(); } @@ -744,10 +749,10 @@ } if ($commands[0] eq "m") { if (weechat::config_string($config{'options'}{'filter_mode'}) eq "normal") { - weechat::command("", "/set rssagg.look.filter_mode reverse"); + weechat::command("", "/mute /set rssagg.look.filter_mode reverse"); } else { - weechat::command("", "/set rssagg.look.filter_mode normal"); + weechat::command("", "/mute /set rssagg.look.filter_mode normal"); } } } @@ -821,45 +826,69 @@ sub process_cb { my ($data, $command, $return_code, $out, $err) = @_; if ($return_code > 0) { # cURL error - weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Error with command: $command ($return_code)"); - weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Command Error: $err") if ($err ne ""); - weechat::command("", "/rssagg stop $data"); - $partial_feed = ""; + weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: cURL error: ($return_code) $err"); + weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Command: $command"); + if (weechat::config_integer($config{'options'}{'autostop'}) ) { + $feeds{"$data"}{"autostop"}++; + if ($feeds{"$data"}{"autostop"} >= weechat::config_integer($config{'options'}{'autostop'}) ) { + weechat::command("", "/rssagg stop $data"); + $feeds{"$data"}{"autostop"} = 0; + } + } + $partial_feed{"$data"} = ""; # delete if defined } elsif ($return_code == weechat::WEECHAT_HOOK_PROCESS_ERROR) { weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Error with fetching of feed: \"$data\". Maybe the site is down."); - weechat::command("", "/rssagg stop $data"); - $partial_feed = ""; + if (weechat::config_integer($config{'options'}{'autostop'}) ) { + $feeds{"$data"}{"autostop"}++; + if ($feeds{"$data"}{"autostop"} >= weechat::config_integer($config{'options'}{'autostop'}) ) { + weechat::command("", "/rssagg stop $data"); + $feeds{"$data"}{"autostop"} = 0; + } + } + $partial_feed{"$data"} = ""; } elsif ($return_code == weechat::WEECHAT_HOOK_PROCESS_RUNNING) { # handle multiple callbacks. Long feeds - $partial_feed .= $out; + $partial_feed{"$data"} .= $out; return weechat::WEECHAT_RC_OK; } elsif ($return_code == 0 && $out) { my $feed; - if ($partial_feed ne "") { - $partial_feed .= $out; - if ($partial_feed !~ /\<\?xml version=/) { # RSS feeds have and tags - weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Feed with name \"$data\" does not appear to be an RSS/Atom feed. This script will only work with RSS/Atom feeds."); - weechat::command("", "/rssagg stop $data"); - $partial_feed = ""; + if ($partial_feed{"$data"} ne "") { + $partial_feed{"$data"} .= $out; + if ($partial_feed{"$data"} !~ /\<\?xml version=/) { # RSS feeds have and tags + weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Feed with name \"$data\" does not appear to be an RSS/Atom feed. The fetched document is not a valid feed."); + if (weechat::config_integer($config{'options'}{'autostop'}) ) { + $feeds{"$data"}{"autostop"}++; + if ($feeds{"$data"}{"autostop"} >= weechat::config_integer($config{'options'}{'autostop'}) ) { + weechat::command("", "/rssagg stop $data"); + $feeds{"$data"}{"autostop"} = 0; + } + } + $partial_feed{"$data"} = ""; return weechat::WEECHAT_RC_OK; } else { - $feed = XML::FeedPP->new($partial_feed, -type => 'string', utf8_flag => 1); - $partial_feed = ""; + $feed = XML::FeedPP->new($partial_feed{"$data"}, -type => 'string', utf8_flag => 1); + $partial_feed{"$data"} = ""; } } else { if ($out !~ /\<\?xml version=/) { # Atom feeds have tag - weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Feed with name \"$data\" does not appear to be an RSS feed. This script will only work with RSS feeds."); - weechat::command("", "/rssagg stop $data"); - $partial_feed = ""; + weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Feed with name \"$data\" does not appear to be an RSS/RDF/Atom feed. The fetched document is not a valid feed."); + if (weechat::config_integer($config{'options'}{'autostop'}) ) { + $feeds{"$data"}{"autostop"}++; + if ($feeds{"$data"}{"autostop"} >= weechat::config_integer($config{'options'}{'autostop'}) ) { + weechat::command("", "/rssagg stop $data"); + $feeds{"$data"}{"autostop"} = 0; + } + } + $partial_feed{"$data"} = ""; return weechat::WEECHAT_RC_OK; } else { $feed = XML::FeedPP->new($out, -type => 'string', utf8_flag => 1); - $partial_feed = ""; + $partial_feed{"$data"} = ""; } } if ($feed ne "") { @@ -914,7 +943,7 @@ weechat::print("", weechat::prefix("error")."$SCRIPT_NAME: Error: failed to parse feed: $data\nTry restarting the feed in a couple minutes."); weechat::command("", "/rssagg stop $data"); } - $partial_feed = ""; # reset $partial_feed + $partial_feed{"$data"} = ""; # reset $partial_feed } return weechat::WEECHAT_RC_OK; } @@ -942,11 +971,7 @@ $feeds{"$data"}{'last_call'} = strftime "%H:%M", localtime; if ($rsslist_buffer ne "") { # update rsslist window @feeds = sort(@feeds); - for (0..$#feeds) { - if ($data eq "$feeds[$_]") { - refresh_line($_); - } - } + refresh_feed_line($data); } return weechat::WEECHAT_RC_OK; } @@ -954,9 +979,12 @@ sub autostart_cb { my ($feed, $remaining) = @_; unless (exists $feeds{"$feed"}{'timer'}) { + $partial_feed{"$feed"} = ""; timer_cb($feed); $feeds{"$feed"}{'timer'} = weechat::hook_timer(weechat::config_integer($feeds{"$feed"}{'delay'}) * 60000, 0, 0, "timer_cb", $feed); + refresh_feed_line($feed); } + delete $feeds{"$feed"}{'autostart'} if (exists $feeds{"$feed"}{'autostart'}); return weechat::WEECHAT_RC_OK; } # hooked config options @@ -1077,6 +1105,20 @@ } return weechat::WEECHAT_RC_OK; } + if ($args[0] eq "last") { + if (@buffer_lines) { + if ($args[1] && ($args[1] =~ /^\d+$/)) { + my $last = weechat::config_integer($config{'options'}{'buffer_max_headlines'}); + $last = $args[1] if ($args[1] < $last); + for (my $i = scalar @buffer_lines - $last; $i <= $#buffer_lines; $i++) { + weechat::print($buffer, "$buffer_lines[$i]"); + } + } + else { + weechat::print($buffer, "$_") for @buffer_lines; + } + } + } if ($args[0] eq "add") { if ($args[2]) { if (weechat::config_search_option($config_file, $config{'sections'}{'feeds'}, "$args[1]")) { @@ -1163,12 +1205,17 @@ weechat::print("", "Feed is already running: $args[1]"); } elsif (exists $feeds{"$args[1]"}{'link'}) { + $partial_feed{"$args[1]"} = ""; timer_cb($args[1]); # hook process for initial feed fetch # hook timer $feeds{"$args[1]"}{'timer'} = weechat::hook_timer(weechat::config_integer($feeds{"$args[1]"}{'delay'}) * 60000, 0, 0, "timer_cb", $args[1]); weechat::print($buffer, "Started feed: $args[1]") if ($buffer_name ne "rsslist"); set_buffer_title(); refresh_feed_line($args[1]); + if (exists $feeds{"$args[1]"}{'autostart'}) { + weechat::unhook($feeds{"$args[1]"}{'autostart'}); + delete $feeds{"$args[1]"}{'autostart'}; + } } else { weechat::print($buffer, "Cannot find feed: $args[1]"); @@ -1185,6 +1232,7 @@ # destroy feed timer delete $feeds{"$args[1]"}{'timer'}; delete $feeds{"$args[1]"}{'last_call'}; + delete $partial_feed{"$args[1]"}; clean_tmp("$args[1]"); weechat::print($buffer, "Stopped feed: $args[1]") if ($buffer_name ne "rsslist"); set_buffer_title(); @@ -1282,7 +1330,8 @@ weechat::hook_config("rssagg.*", "config_cb", ""); weechat::hook_completion("rssagg_feeds", "List of RSS feeds", "command_completion_cb", ""); weechat::hook_command($SCRIPT_NAME, $SCRIPT_DESC, # command, command description - "list || add || cookie || del || restart || start || stop ", # args + "last || list || add || cookie || del || restart || start || stop ", # args + " last: Show last n number of feeds in current buffer (defaults to rssagg.look.buffer_max_headlines)\n". " list: List all feeds (you must have at least one feed)\n". # args description " add: Add a new feed\n". " cookie: Add a cookie to a feed\n". @@ -1327,7 +1376,7 @@ " /rssagg start feed2\n". " stop a running feed with name \"feed2\":\n". " /rssagg stop feed2", - "list %-|| add * * %-|| cookie %(rssagg_feeds) * %-|| del %(rssagg_feeds) %-|| restart %(rssagg_feeds) %-|| start %(rssagg_feeds) %-|| stop %(rssagg_feeds) %-", # completion + "last * %-|| list %-|| add * * %-|| cookie %(rssagg_feeds) * %-|| del %(rssagg_feeds) %-|| restart %(rssagg_feeds) %-|| start %(rssagg_feeds) %-|| stop %(rssagg_feeds) %-", # completion "command_rss", ""); # callback, callback data ######################### STARTUP ######################### @@ -1345,8 +1394,8 @@ if (weechat::config_integer($config{'options'}{'autostart_on_load'})) { for (my $i = 0; $i <= $#feeds; $i++) { if ($feeds[$i]) { - my $interval = $i * 60000 * weechat::config_integer($config{'options'}{'autostart_delay'}); - weechat::hook_timer($interval, 0, 1, "autostart_cb", $feeds[$i]); + my $interval = $i * 60000 * weechat::config_integer($config{'options'}{'autostart_delay'}) + 1; + $feeds{"$feeds[$i]"}{'autostart'} = weechat::hook_timer($interval, 0, 1, "autostart_cb", $feeds[$i]); } } } diff -Nru weechat-scripts-20130123/perl/sort_buffers.pl weechat-scripts-20131007/perl/sort_buffers.pl --- weechat-scripts-20130123/perl/sort_buffers.pl 2013-01-23 19:00:25.000000000 +0000 +++ weechat-scripts-20131007/perl/sort_buffers.pl 2013-10-07 12:14:56.000000000 +0000 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011 by Nils Görs +# Copyright (c) 2011-2013 by Nils Görs # # irc-buffers will be sorted alphabetically or in reverse order # @@ -18,50 +18,93 @@ # # 2011-04-14, nils_2: # version 0.1: initial release +# 2013-07-16, prurigro: +# version 0.2: fixed sorting duplicate channel names on different servers +# 2013-07-20, nils_2: +# version 0.3: add options for script on hook_signal("buffer_opened") +# : fix bug when irc.look.server_buffer was independent use strict; my $PRGNAME = "sort_buffers"; -my $VERSION = "0.1"; +my $VERSION = "0.3"; my $DESCR = "irc-buffers will be sorted alphabetically or in reverse order"; -my %buffer_struct = (); # to store servername and buffername +my $weechat_version = ""; +my %buffer_struct = (); # to store servername and buffername my $default_start_after_position = 2; -my $i = 0; -my $args_all = 0; -my $args_reverse = 0; +my $i = 0; +my $args_all = 0; +my $args_reverse = 0; + +# default values +my %options = ("sort_order" => ["default", "sort of buffers \"default\" or \"reverse\" order. This option takes only effect when option \"hook_signal\" is on."], # or reverse + "server_wide" => ["on", "buffers will be sorted server wide. This option takes only effect when option \"hook_signal\" is on."], + "hook_signal" => ["off","if \"on\" buffers will be sort every time a buffer was opened. Keep in mind that sorting buffers will delete read_marker."], + ); + +# -----------------------------[ config ]----------------------------------- +sub init_config{ + foreach my $option (keys %options){ + if (!weechat::config_is_set_plugin($option)){ + weechat::config_set_plugin($option, $options{$option}[0]); + }else{ + $options{$option}[0] = weechat::config_get_plugin($option); + } + if ($weechat_version >= 0x00030500){ + weechat::config_set_desc_plugin($option, $options{$option}[1] . " (default: " . $options{$option}[0] . ")"); + } + } +} +sub toggle_config_by_set{ + my ($pointer, $name, $value) = @_; + $name = substr($name, length("plugins.var.perl.$PRGNAME."), length($name)); + $options{$name}[0] = $value; + return weechat::WEECHAT_RC_OK; +} sub get_buffer_list{ -my $buffer_pnt = weechat::infolist_get("buffer","",""); - - my $buffer_name = ""; - my $buffer_short_name = ""; - my $buffer_plugin_name = ""; - my $server_name = ""; - my $buffer_number = ""; - - while ( weechat::infolist_next($buffer_pnt) ){ - $buffer_plugin_name = weechat::infolist_string($buffer_pnt,"plugin_name"); # get plugin_name of buffer - $buffer_name = weechat::infolist_string($buffer_pnt,"name"); # get name of buffer - $buffer_number = weechat::infolist_integer($buffer_pnt,"number"); # get number of buffer - $buffer_short_name = weechat::infolist_string($buffer_pnt,"short_name"); # get short_name of buffer - - if ( $buffer_plugin_name eq "irc" ){ - $buffer_name =~ /(.+?)\.(.*)/; # strip at first dot ( servername dot #buffername ) - $server_name = $1; - if ( $server_name eq "server") { - next; - } - if ( $args_all == 1){ + my $infolist = weechat::infolist_get("buffer","",""); + while ( weechat::infolist_next($infolist) ){ + my $buffer_plugin_name = weechat::infolist_string($infolist,"plugin_name"); # get plugin_name of buffer + my $buffer_name = weechat::infolist_string($infolist,"name"); # get name of buffer + my $buffer_full_name = weechat::infolist_string($infolist,"full_name"); # get full_name of buffer + my $buffer_number = weechat::infolist_integer($infolist,"number"); # get number of buffer + my $buffer_short_name = weechat::infolist_string($infolist,"short_name"); # get short_name of buffer + my $server_name = weechat::buffer_get_string(weechat::infolist_pointer($infolist,"pointer"),"localvar_server"); + my $localvar_type = weechat::buffer_get_string(weechat::infolist_pointer($infolist,"pointer"),"localvar_type"); + + if ($buffer_plugin_name eq "core"){ + if ($args_all == 1){ + $buffer_struct{"all_in_one"}{$buffer_full_name}{buffer_short_name} = $server_name; + }else{ + $buffer_struct{$buffer_full_name}{$buffer_full_name}{buffer_number}=$buffer_number; # core.weechat + } + } + if ($buffer_plugin_name eq "irc"){ # irc buffer + if ($localvar_type eq "server"){ # server buffer + if ($args_all == 1){ + $buffer_struct{"all_in_one"}{$buffer_full_name}{buffer_short_name} = $server_name; + }else{ + $buffer_struct{$server_name}{$buffer_name}{buffer_number}=$buffer_number; # server.name + } + }elsif ($localvar_type eq "channel" or $localvar_type eq "private"){ + if ($args_all == 1){ $buffer_struct{"all_in_one"}{$buffer_name}{buffer_short_name}=$buffer_short_name; }else{ - $buffer_struct{$server_name}{$buffer_short_name}{buffer_number}=$buffer_number; + $buffer_struct{$buffer_name}{$buffer_short_name}{buffer_number}=$buffer_number; + } } + }elsif ($buffer_plugin_name ne "irc" or $buffer_plugin_name ne "core"){ # buffer with free content + if ($args_all == 1){ + $buffer_struct{"all_in_one"}{$buffer_full_name}{buffer_short_name} = $server_name; + }else{ + $buffer_struct{$buffer_full_name}{$buffer_full_name}{buffer_number}=$buffer_number; + } } } - -weechat::infolist_free($buffer_pnt); +weechat::infolist_free($infolist); } # sort z-a @@ -74,6 +117,12 @@ } }else{ foreach my $s ( reverse sort keys %buffer_struct ) { + foreach my $n ( sort { $buffer_struct{$s}{$b}->{buffer_short_name} cmp $buffer_struct{$s}{$a}->{buffer_short_name}} keys %{$buffer_struct{$s}} ) { + buffer_movement($n); + } + } + + foreach my $s ( reverse sort keys %buffer_struct ) { foreach my $n ( reverse sort keys %{$buffer_struct{$s}} ) { buffer_movement($n); } @@ -91,6 +140,12 @@ } }else{ foreach my $s ( sort keys %buffer_struct ) { + foreach my $n ( sort { $buffer_struct{$s}{$a}->{buffer_short_name} cmp $buffer_struct{$s}{$b}->{buffer_short_name}} keys %{$buffer_struct{$s}} ) { + buffer_movement($n); + } + } + + foreach my $s ( sort keys %buffer_struct ) { foreach my $n ( sort keys %{$buffer_struct{$s}} ) { buffer_movement($n); } @@ -99,6 +154,7 @@ } sub buffer_movement{ my $n = $_[0]; + return if ($n eq ""); weechat::command("","/buffer " . $n); weechat::command("","/buffer move " . $i); $i++; @@ -106,18 +162,18 @@ sub sort_buffers_cmd{ my ($data, $buffer, $args) = ($_[0], $_[1], $_[2]); -my $from_buffer_called = weechat::buffer_get_string($buffer,"name"); # save buffer command was executed from +my $from_buffer_called = weechat::buffer_get_string($buffer,"name"); # save buffer, command was executed from # set variables to default value %buffer_struct = (); - $args_reverse = 0; - $args_all = 0; - $i = $default_start_after_position; + $args_reverse = 0; + $args_all = 0; + $i = $default_start_after_position; - if ( $args eq "" ){ # no args! use standard settings + if ( $args eq "" ){ # no args! use standard settings get_buffer_list(); normal_sort(); - }else{ # arguments given + }else{ # arguments given my @args_array=split(/ /,$args); $i = $args_array[0] if ( $args_array[0] =~ /^\d*$/ ); @@ -134,15 +190,66 @@ reverse_sort(); } } - weechat::command("","/buffer " . $from_buffer_called); # go back to buffer command was executed from + look_server_buffer(); + weechat::command("","/buffer " . $from_buffer_called); # switch to buffer, command was executed from + return weechat::WEECHAT_RC_OK; +} + +sub look_server_buffer{ + my $look_server = weechat::config_string(weechat::config_get("irc.look.server_buffer")); + if ($look_server eq "merge_with_core") + { + weechat::command("","/buffer core.weechat"); + weechat::command("","/buffer move 1"); + } + else + { + weechat::command("","/buffer core.weechat"); + weechat::command("","/buffer move 1"); + my $infolist = weechat::infolist_get("buffer","","*server.*"); + weechat::infolist_next($infolist); + weechat::command("","/buffer " . weechat::infolist_string($infolist, "name")); + weechat::command("","/buffer move 2"); + weechat::infolist_free($infolist); # do not forget to free infolist! + } +} +sub buffer_opened_cb{ + my ($data, $signal, $signal_data) = ($_[0], $_[1], $_[2]); + my $from_buffer_called = weechat::buffer_get_string($signal_data,"name"); # save buffer command was executed from + return weechat::WEECHAT_RC_OK if ( $options{hook_signal}[0] eq "off" ); + +# set variables to default value + %buffer_struct = (); + $args_reverse = 0; + $args_all = 0; + $i = $default_start_after_position; + + if ( $options{server_wide}[0] eq "on" ){ + $args_all = 1; + }else{ + get_buffer_list(); + normal_sort(); + look_server_buffer(); + weechat::command("","/buffer " . $from_buffer_called); # go back to buffer command was executed from + return weechat::WEECHAT_RC_OK; + } + if ( $options{sort_order}[0] eq "default" ){ # or reverse? + get_buffer_list(); + normal_sort(); + }elsif( $options{sort_order}[0] eq "reverse" ){ + $args_reverse = 1; + get_buffer_list(); + reverse_sort(); + } + look_server_buffer(); + weechat::command("","/buffer " . $from_buffer_called); # switch to buffer, command was executed from return weechat::WEECHAT_RC_OK; } # -------------------------------[ init ]------------------------------------- # first function called by a WeeChat-script. weechat::register($PRGNAME, "Nils Görs ", $VERSION, "GPL3", $DESCR, "", ""); -weechat::hook_command($PRGNAME, $DESCR, " || reverse || all", - ": start at position n (default: 2)\n". +weechat::hook_command($PRGNAME, $DESCR, "reverse || all", "all : sort irc-buffers server-wide\n". "reverse : sort irc-buffers in reverse order\n". "\n". @@ -150,7 +257,11 @@ " Sort irc-buffers alphabetically, server by server\n". " /$PRGNAME\n". " Sort irc-buffers alphabetically, server-wide\n". - " /$PRGNAME all\n". - " Sort all irc-buffers in reverse order. Buffers will be pointed beginning from position 1\n". - " /$PRGNAME 1 all reverse\n", + " /$PRGNAME all\n", "all|reverse|%*", "sort_buffers_cmd", ""); + +$weechat_version = weechat::info_get("version_number", ""); + +weechat::hook_config("plugins.var.perl.$PRGNAME.*", "toggle_config_by_set", ""); +weechat::hook_signal("buffer_opened","buffer_opened_cb",""); +init_config(); diff -Nru weechat-scripts-20130123/perl/spacer.pl weechat-scripts-20131007/perl/spacer.pl --- weechat-scripts-20130123/perl/spacer.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/spacer.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,49 @@ +# +# Copyright (c) 2013 by Biohazard +# +# adds a /spacer command that adds a space between every character in the text supplied +# +# 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 . +# +# usage: +# /spacer - adds a space between every character in the text supplied +# can also be bound to a keybinding, so the effect applies to the text in the current buffer's input bar. +# +# history: +# 0.1 - Initial release + +use warnings; +use strict; + +$INC{'Encode/ConfigLocal.pm'}=1; +require Encode; + +my $script_name = "spacer"; +my $author = "Biohazard"; +my $version = "0.1"; +my $license = "GPL3"; +my $description = "Adds spaces between each character in the chat box"; + +weechat::register($script_name, $author, $version, $license, $description, "", ""); +weechat::hook_command($script_name, $description, "", "", "", $script_name, ""); + +sub spacer { + Encode::_utf8_on(my $text = $_[2]); + Encode::_utf8_on($text = weechat::buffer_get_string(weechat::current_buffer, "input")) if not $text; + + $text = join(" ", split(//, $text)); + weechat::buffer_set(weechat::current_buffer, "input", $text); + + return weechat::WEECHAT_RC_OK; +} diff -Nru weechat-scripts-20130123/perl/spell_menu.pl weechat-scripts-20131007/perl/spell_menu.pl --- weechat-scripts-20130123/perl/spell_menu.pl 2013-01-23 19:00:27.000000000 +0000 +++ weechat-scripts-20131007/perl/spell_menu.pl 2013-10-07 12:14:58.000000000 +0000 @@ -31,6 +31,21 @@ hint: if it breaks your tab completion, you can toggle the spell checker (default key in weechat is Alt+S) +=head1 CAVEATS + +=over + +=item * + +on update of spell_menu from v0.3 to v0.4 you might need to do + + /unset menu.var.spell.* + /script reload spell_menu + +to get rid of stale entries. sorry about that. + +=back + =head1 SETTINGS the settings are usually found in the @@ -72,7 +87,7 @@ =cut use constant SCRIPT_NAME => 'spell_menu'; -weechat::register(SCRIPT_NAME, 'Nei ', '0.3', 'GPL3', 'spell checker menu', '', '') || return; +weechat::register(SCRIPT_NAME, 'Nei ', '0.4', 'GPL3', 'spell checker menu', '', '') || return; sub SCRIPT_FILE() { my $infolistptr = weechat::infolist_get('perl_script', '', SCRIPT_NAME); my $filename = weechat::infolist_string($infolistptr, 'filename') if weechat::infolist_next($infolistptr); @@ -137,10 +152,6 @@ } $$target = $r; - my $code = qq{ - local \$[=1; - \$list{"\Q$key\E"}$idx = \$r - }; $key => $list{$key} } else { @@ -154,6 +165,11 @@ } ## hdh -- hdata helper +## $_[0] - arg pointer or hdata list name +## $_[1] - hdata name +## $_[2..$#_] - hdata variable name +## $_[-1] - hashref with key/value to update (optional) +## returns value of hdata, and hdata name in list ctx, or number of variables updated sub hdh { if (@_ > 1 && $_[0] !~ /^0x/ && $_[0] !~ /^\d+$/) { my $arg = shift; @@ -162,17 +178,22 @@ while (@_ > 2) { my ($arg, $name, $var) = splice @_, 0, 3; my $hdata = weechat::hdata_get($name); + unless (ref $var eq 'HASH') { + $var =~ s/!(.*)/weechat::hdata_get_string($hdata, $1)/e; + (my $plain_var = $var) =~ s/^\d+\|//; + my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); + if ($type eq 'pointer') { + my $name = weechat::hdata_get_var_hdata($hdata, $var); + unshift @_, $name if $name; + } - (my $plain_var = $var) =~ s/^\d+\|//; - my $type = weechat::hdata_get_var_type_string($hdata, $plain_var); - if ($type eq 'pointer') { - my $name = weechat::hdata_get_var_hdata($hdata, $var); - unshift @_, $name if $name; + my $fn = "weechat::hdata_$type"; + unshift @_, do { no strict 'refs'; + &$fn($hdata, $arg, $var) }; + } + else { + return weechat::hdata_update($hdata, $arg, $var); } - - my $fn = "weechat::hdata_$type"; - unshift @_, do { no strict 'refs'; - &$fn($hdata, $arg, $var) }; } wantarray ? @_ : $_[0] } @@ -218,6 +239,8 @@ } ## mangle_man_for_wee -- turn man output into weechat codes +## @_ - list of grotty lines that should be turned into weechat attributes +## returns modified lines and modifies lines in-place sub mangle_man_for_wee { for (@_) { s/_\x08(.)/weechat::color('underline').$1.weechat::color('-underline')/ge; @@ -249,8 +272,9 @@ my $buf = weechat::buffer_new("man $name", '', '', '', ''); return weechat::WEECHAT_RC_OK unless $buf; - my $width = $wininfo->{'chat_width'}; - --$width if $wininfo->{'chat_width'} < $wininfo->{'width'} || ($wininfo->{'width_pct'} < 100 && (grep { $_->{'y'} == $wininfo->{'y'} } Nlib::i2h('window'))[-1]{'x'} > $wininfo->{'x'}); + my $width = $wininfo->{chat_width}; + --$width if $wininfo->{chat_width} < $wininfo->{width} || ($wininfo->{width_pct} < 100 && (grep { $_->{y} == $wininfo->{y} } Nlib::i2h('window'))[-1]{x} > $wininfo->{x}); + $width -= 2; # when prefix is shown weechat::buffer_set($buf, 'time_for_each_line', 0); eval qq{ @@ -259,22 +283,22 @@ }; die $@ if $@; - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input history_previous' || - $_->{'command'} eq '/input history_global_previous' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input history_previous' || + $_->{command} eq '/input history_global_previous' } @wee_keys; @keys = 'meta2-A' unless @keys; weechat::buffer_set($buf, "key_bind_$_", '/window scroll -1') for @keys; - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input history_next' || - $_->{'command'} eq '/input history_global_next' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input history_next' || + $_->{command} eq '/input history_global_next' } @wee_keys; @keys = 'meta2-B' unless @keys; weechat::buffer_set($buf, "key_bind_$_", '/window scroll +1') for @keys; weechat::buffer_set($buf, 'key_bind_ ', '/window page_down'); - @keys = map { $_->{'key'} } - grep { $_->{'command'} eq '/input delete_previous_char' } @wee_keys; + @keys = map { $_->{key} } + grep { $_->{command} eq '/input delete_previous_char' } @wee_keys; @keys = ('ctrl-?', 'ctrl-H') unless @keys; weechat::buffer_set($buf, "key_bind_$_", '/window page_up') for @keys; @@ -283,7 +307,7 @@ weechat::buffer_set($buf, 'key_bind_q', '/buffer close'); - weechat::print($buf, " \t".mangle_man_for_wee($_)) + weechat::print($buf, " \t".mangle_man_for_wee($_)) # weird bug with \t\t showing nothing? for `pod2man \Q$file\E 2>/dev/null | GROFF_NO_SGR=1 nroff -mandoc -rLL=${width}n -rLT=${width}n -Tutf8 2>/dev/null`; weechat::command($buf, '/window scroll_top'); @@ -306,18 +330,23 @@ use constant ASPELL_PLANG_PWS => 1; +my %spell_menu; init_spell_menu(); weechat::hook_config('plugins.var.perl.'.SCRIPT_NAME.'.*', 'default_options', ''); weechat::hook_command_run('/input complete_next', 'spell_menu', ''); +weechat::hook_info_hashtable('spell_menu', 'spell menu content', '', 'list of 123.command and 123.name pairs for insertion into menu', 'spell_menu', ''); weechat::hook_command(SCRIPT_NAME, 'open the spell correction menu', '', "use @{[weechat::color('bold')]}/@{[SCRIPT_NAME]} help@{[weechat::color('-bold')]} to read the manual", '', 'spell_menu', ''); ## spell_menu -- show the spell menu and fix spellings ## () - command_run or command handler -## $_[1] - buffer +## $_[1] - buffer or infohash name ## $_[2] - command or arg sub spell_menu { + if (ref $_[2]) { + return \%spell_menu; + } if ($_[2] =~ /^\s*help\s*$/i) { Nlib::read_manpage(SCRIPT_FILE, SCRIPT_NAME); return weechat::WEECHAT_RC_OK @@ -328,14 +357,10 @@ my $fix = $1 if $_[2] =~ /^fix (\d+)/; my $badword; ($badword, $sugs) = split ':', $sugs, 2; - weechat::command('', '/mute /unset menu.var.spell.*'); Encode::_utf8_on(my $q = weechat::buffer_get_string($_[1], 'input')); my $pos = weechat::buffer_get_integer($_[1], 'input_pos'); - my $rpos = index $q, $badword; + my $rpos = rindex $q, $badword, $pos; return weechat::WEECHAT_RC_OK unless $rpos >= 0; - for (my $f = $rpos; $f >= 0 && $f <= $pos; $f = index $q, $badword, $f+1) { - $rpos = $f; - } if ($fix) { my $goodword = (split '[,/]', $sugs)[$fix-1]; (substr $q, $rpos, length $badword) = $goodword; @@ -356,6 +381,7 @@ if weechat::config_string_to_boolean(weechat::config_get_plugin('complete_noend')) && $pos == $offset; } + my %r; my ($i, $j, $dc) = (0, 0, 0); my %seen; my @shortcut = (undef, 1..9, 0, 'a'..'z'); @@ -365,15 +391,15 @@ if ($sug eq '/') { # next dict ++$dc; last if $dc >= @dict; # work around bug in weechat - weechat::command('', "/mute /set menu.var.spell.${j}9.name [@{[weechat::color('bold')]}$dict[$dc]@{[weechat::color('-bold')]}]"); + $r{"${j}9.name"} = "[@{[weechat::color('bold')]}$dict[$dc]@{[weechat::color('-bold')]}]"; next; } ++$i; next if $seen{$sug}++; $j = sprintf '%02d', $j + 1; last if $j >= @shortcut; - weechat::command('', "/mute /set menu.var.spell.$j.command /@{[SCRIPT_NAME]} fix $i"); - weechat::command('', "/mute /set menu.var.spell.$j.name &$shortcut[$j] $sug"); + $r{"$j.command"} = "/@{[SCRIPT_NAME]} fix $i"; + $r{"$j.name"} = "&$shortcut[$j] $sug"; } if (@dict > 1) { $dc = 0; @@ -383,14 +409,15 @@ } for (@dict) { $dc = sprintf '%02d', $dc + 1; - weechat::command('', "/mute /set menu.var.spell.9$dc.command /aspell addword $dict[$dc-1] \$0"); - weechat::command('', "/mute /set menu.var.spell.9$dc.name ADD($dict[$dc-1]) $badword"); + $r{"9$dc.command"} = "/aspell addword $dict[$dc-1] \$0"; + $r{"9$dc.name"} = "ADD($dict[$dc-1]) $badword"; } } else { - weechat::command('', '/mute /set menu.var.spell.9.command /aspell addword $0'); - weechat::command('', "/mute /set menu.var.spell.9.name ADD $badword"); + $r{'9.command'} = '/aspell addword $0'; + $r{'9.name'} = "ADD $badword"; } + %spell_menu = %r; weechat::command($_[1], "/menu spell $badword"); } $_[2] =~ /^\// ? weechat::WEECHAT_RC_OK_EAT : weechat::WEECHAT_RC_OK @@ -417,5 +444,6 @@ for (Nlib::get_settings_from_pod($sf)) { weechat::config_set_desc_plugin($_, Nlib::get_desc_from_pod($sf, $_)); } + weechat::command('', '/mute /set menu.var.spell.0.command %#spell_menu% % '); weechat::WEECHAT_RC_OK } diff -Nru weechat-scripts-20130123/perl/stalker.pl weechat-scripts-20131007/perl/stalker.pl --- weechat-scripts-20130123/perl/stalker.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/stalker.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,1100 @@ +# +# Copyright (c) 2013 by Nils Görs +# Copyright (c) 2013 by Stefan Wold +# based on irssi script stalker.pl from Kaitlyn Parkhurst (SymKat) +# https://github.com/symkat/Stalker +# +# Records and correlates nick!user@host information +# +# 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 . +# +# History: +# +# version 0.9: Ratler@freenode.#weechat +# 2013-08-11: fix: removed trailing whitespaces +# fix: only add index if it doesn't exist +# fix: dynamically create or upgrade database based on missing tables or columns +# fix: allow dynamically creating indices for future tables +# +# version 0.8: Ratler@freenode.#weechat +# 2013-08-09: add: case insensitive nick search +# add: show "server.nickname" in search results when search_this_network_only is set to off +# fix: type no longer needed for _ignore_guests() +# +# version 0.7: nils_2@freenode.#weechat +# 2013-08-04: add: support of colors with format "${color:xxx}" (>= WeeChat 0.4.2) +# add: function "remove_nick_from_host" (patch by FiXato) +# +# version 0.6: nils_2@freenode.#weechat +# 2013-05-27: cleanup code +# +# version 0.5: nils_2@freenode.#weechat +# 2013-05-26: add: function 'count' +# +# version 0.4: nils_2@freenode.#weechat +# 2013-05-18: add: option 'tags' +# +# version 0.3: nils_2@freenode.#weechat +# 2013-05-05: fix: typos in help and description option (thanks FiXato) +# add: 'ChanServ' to option 'guest_nick_regex' +# +# version 0.2: nils_2@freenode.#weechat +# 2013-05-01: fix: bug with regular expressions using /whois +# removed: option 'allow_regex_for_search' +# add: command option '-regex' +# +# version 0.1: nils_2@freenode.#weechat +# 2013-04-23: - initial release - +# +# thanks to firebird and mave_ for testing... +# +# Development is currently hosted at +# https://github.com/weechatter/weechat-scripts +# +# Requires: +# DBI +# DBD::SQLite +# +# How to install DBI: +# with cpan : install DBI +# with deb-package: sudo apt-get install libdbi-perl +# +# How to install DBD::SQLite: +# with cpan : install DBD::SQLite +# with deb-package: sudo apt-get install libdbd-sqlite3-perl libdbd-sqlite3 + +#use strict; +use warnings; +use File::Spec; +use DBI; + +my $SCRIPT_NAME = "stalker"; +my $SCRIPT_VERSION = "0.9"; +my $SCRIPT_AUTHOR = "Nils Görs "; +my $SCRIPT_LICENCE = "GPL3"; +my $SCRIPT_DESC = "Records and correlates nick!user\@host information"; + + +# internal values +my $weechat_version = ""; + +# default values +my %options = ('db_name' => '%h/nicks.db', + 'debug' => 'off', + 'max_recursion' => '20', + 'recursive_search' => 'on', + 'ignore_guest_hosts' => 'off', + 'ignore_guest_nicks' => 'on', + 'guest_nick_regex' => '^(guest|weebot|Floodbot|ChanServ).*', + 'guest_host_regex' => '^webchat', + 'normalize_nicks' => 'on', + 'search_this_network_only' => 'on', + 'use_localvar' => 'off', + 'ignore_nickchange' => 'off', + 'ignore_whois' => 'off', + 'tags' => '', +# '' => '', +); +my %desc_options = ('db_name' => 'file containing the SQLite database where information is recorded. This database is created on loading of ' . $SCRIPT_NAME . ' if it does not exist. ("%h" will be replaced by WeeChat home, "~/.weechat" by default) (default: %h/nicks.db)', + 'debug' => 'Prints debug output to core buffer so you know exactly what is going on. This is far too verbose to be enabled when not actively debugging something. (default: off)', + 'max_recursion' => 'For each correlation between nick <-> host that happens, one point of recursion happens. A corrupt database, general evilness, or misfortune can cause the recursion to skyrocket. This is a ceiling number that says if after this many correlation attempts we have not found all nickname and hostname correlations, stop the process and return the list to this point.', + 'recursive_search' => 'When enabled, recursive search causes stalker to function better than a simple hostname to nickname map. Disabling the recursive search in effect turns stalker into a more standard hostname -> nickname map.', + 'ignore_guest_hosts'=> 'See option guest_host_regex', + 'guest_host_regex' => 'regex mask to ignore host masks', + 'ignore_guest_nicks'=> 'See option guest_nick_regex', + 'guest_nick_regex' => 'Some networks set default nicknames when a user fails to identify to nickserv, other networks using relay-bots, some irc clients set default nicknames when someone connects and often these change from network to network depending on who is configuring the java irc clients. This allows a regular expression to be entered. When a nickname matches the regular expression and "ignore_guest_nicks" is enabled the nickname is dropped from the search as if it had never been seen. (default: ^(guest|weebot|Floodbot).*)', + 'normalize_nicks' => 'this option will truncate special chars from username (like: ~) (default: on)', + 'search_this_network_only' => 'When enabled searches are limited to within the network the window is currently set on. Turning this off is really only useful if multiple networks don\'t encode the hostmask. (default: on)', + 'use_localvar' => 'When enabled, only channels with a localvar \'stalker\' will be monitored. This option will not affect /NICK and /WHOIS monitoring. It\'s only for /JOIN messages. (default: off)', + 'ignore_nickchange' => 'When enabled, /NICK changes won\'t be monitored. (default: off)', + 'ignore_whois' => 'When enabled, /WHOIS won\'t be monitored. (default: off)', + 'tags' => 'comma separated list of tags used for messages printed by stalker. See documentation for possible tags (e.g. \'no_log\', \'no_highlight\'). This option does not effect DEBUG messages.', +); + +my $count; +my %data; +my $str; +my $DBH; +my $DBH_child; +my $hook_process = 0; +my $last_nick = ""; +my $last_host = ""; + +# SQLite table definition +my %tables = ( + 'records' => [ + { 'column' => 'nick', 'type' => 'TEXT NOT NULL' }, + { 'column' => 'user', 'type' => 'TEXT NOT NULL' }, + { 'column' => 'host', 'type' => 'TEXT NOT NULL' }, + { 'column' => 'serv', 'type' => 'TEXT NOT NULL' }, + { 'column' => 'added', 'type' => 'DATE NOT NULL DEFAULT CURRENT_TIMESTAMP' }, + ], + ); + +# SQLite index definitions +my %indices = ( + 'records' => [ + { 'name' => 'index1', 'column' => 'nick' }, + { 'name' => 'index2', 'column' => 'host' }, + ], + ); +# -----------------------------[ Database ]----------------------------------- +sub open_database { + my $db = weechat_dir(); + + stat_database( $db ); + my ($db_user, $db_pass); + # my $db_host = '127.0.0.1'; + # my $db_port = 3306; + + $DBH = DBI->connect( + 'dbi:SQLite:dbname='.$db, $db_user, $db_pass, + { + RaiseError => 1, +# AutoCommit => 1, + sqlite_use_immediate_transaction => 1, + } + ); + + # DBI::SQLite and fork() don't mix. Do it anyhow but keep the parent and child DBH separate? + # Ideally the child should open its own connection. + $DBH_child = DBI->connect( + 'dbi:SQLite:dbname='.$db, $db_user, $db_pass, + { + RaiseError => 1, +# AutoCommit => 1, + sqlite_use_immediate_transaction => 1, + } + ); + + # async data + my @records_to_add; # Queue of records to add +} + + +# Automatic Database Creation And Checking +sub stat_database { + my ( $db_file ) = @_; + + DEBUG('info', 'Stat database'); + if ( ! -e $db_file ) { + open my $fh, '>', $db_file + or die 'Cannot create database file. Abort.'; + close $fh; + } + my $DBH = DBI->connect( + 'dbi:SQLite:dbname='.$db_file, "", "", + { + RaiseError => 1, +# AutoCommit => 1, + sqlite_use_immediate_transaction => 1, + } + ); + + create_or_upgrade_database( $DBH ); + + index_db( $DBH ); +} + +sub create_or_upgrade_database { + my ( $DBH ) = @_; + + # This part will always add missing tables or columns defined in @tables (ie create or upgrade the database) + DEBUG("info", "Checking database table structure"); + my %col_exists; + for my $table (keys %tables) { + for my $col ( @{ $DBH->selectall_arrayref ( "PRAGMA TABLE_INFO($table)" ) } ) { + $col_exists{$table}{$col->[1]} = 1; + } + } + for my $table (keys %tables) { + my $upgrade = 0; + + # Create missing tables + unless ( exists( $col_exists{$table} ) ) { + create_table( $DBH, $table ); + next; + } + + # Check for missing columns + my @cols_not_null; + for my $col ( @{$tables{$table}} ) { + unless ( $col_exists{$table}{$col->{column}} ) { + if ( ($col->{type} =~ /NOT NULL/) and ($col->{type} !~ /DEFAULT/) ) { + push @cols_not_null, $col->{column}; + } + $upgrade = 1; + } + } + + # Due to limitations in ALTER TABLE in sqlite this cumbersome method is necessary to alter a table + if ( $upgrade ) { + DEBUG("info", "Upgrade required for table '$table', please wait..."); + # Save the old records + $DBH->do( "ALTER TABLE $table RENAME TO old_$table" ); + + # Preserve old column names for copying of data later + my $old_columns = join( ", ", map { $_->[1] } @{ $DBH->selectall_arrayref( "PRAGMA TABLE_INFO(old_$table)" ) } ); + + # Create the new table + create_table( $DBH, $table ); + + # Special care for NOT NULL columns, we set value 1 for all missing columns defined with NOT NULL or the copy will fail + my $old_select; + if ( scalar(@cols_not_null) > 0 ) { + $old_select = $old_columns . ", " . join(", ", map { 1 } @cols_not_null ); + $old_columns .= ", " . join(", ", @cols_not_null); + } else { + $old_select = $old_columns; + } + + # Copy the old records over and drop them + my @queries = ( + "INSERT INTO $table ($old_columns) SELECT $old_select FROM old_$table", + "DROP TABLE old_$table", + ); + for my $query (@queries) { + my $sth = $DBH->prepare($query) or die "Failed to prepare '$query'. " . $sth->err; + $sth->execute() or die "Failed to execute '$query'. " . $sth->err; + } + DEBUG( "info", "Table '$table' has been successfully upgraded" ) unless ( $DBH->err ); + } + } +} + +# Create table +sub create_table { + my ( $DBH, $table_name ) = @_; + + my @queries; + + DEBUG("info", "Creating table '$table_name'"); + push @queries, "DROP TABLE IF EXISTS $table_name"; + push @queries, "CREATE TABLE $table_name (" . join(", ", map { "$_->{column} $_->{type}" } @{ $tables{$table_name} }) . ")"; + + for my $query (@queries) { + my $sth = $DBH->prepare($query) or die "Failed to prepare '$query'. " . $sth->err; + $sth->execute() or die "Failed to execute '$query'. " . $sth->err; + } +} + +# Add indices to the DB. +sub index_db { + my ( $DBH ) = @_; + + for my $table (keys %indices) { + my %idx_exists; + for my $index ( @{ $DBH->selectall_arrayref( "PRAGMA INDEX_LIST($table)" ) } ) { + $idx_exists{$index->[1]} = 1; + } + + $DBH->{RaiseError} = 0; + $DBH->{PrintError} = 0; + for my $index ( @{$indices{$table}} ) { + $DBH->do( "CREATE INDEX $index->{name} ON $table ($index->{column})" ) unless ( $idx_exists{$index->{name}} ); + } + $DBH->{RaiseError} = 1; + $DBH->{PrintError} = 1; + } +} + +sub normalize { + my ( @nicks ) = @_; + my ( %nicks, %ret ) = map { $_, 1 } @nicks; + + for my $nick ( @nicks ) { + (my $base = $nick ) =~ s/[\Q-_~^`\E]//g; + $ret{ exists $nicks{$base} ? $base : $nick }++; + } + return keys %ret; +} + +sub add_record +{ + my ( $nick, $user, $host, $serv ) = @_; + return unless ($nick and $user and $host and $serv); + + DEBUG("info", "Start child process, to add record to database"); + + my ($command) = db_add_record($nick, $user, $host, $serv); + + if ($hook_process) + { + $hook_process = weechat::hook_process($command, 1000 * 1, "my_hook_process_cb", ""); + }else + { + $hook_process = 0; + } +} + +sub db_add_record +{ + my ($nick, $user, $host, $serv) = @_; + + # Check if we already have this record. + my $q = "SELECT nick FROM records WHERE nick = ? AND user = ? AND host = ? AND serv = ?"; + my $sth = $DBH_child->prepare( $q ); + $sth->execute( $nick, $user, $host, $serv ); + my $result = $sth->fetchrow_hashref; + + if ( defined $result->{nick} ) + { + if ( $result->{nick} eq $nick ) { + DEBUG( "info", "Record for $nick skipped - already exists." ); + return 1; + } + } + + DEBUG("info", "Adding to DB: nick = $nick, user = $user, host = $host, serv = $serv" ); + + # We don't have the record, add it. + $sth = $DBH_child->prepare + ("INSERT INTO records (nick,user,host,serv) VALUES( ?, ?, ?, ? )" ); + eval { $sth->execute( $nick, $user, $host, $serv ) }; + if ($@) { + DEBUG("error", "Failed to process record, database said: $@" ); + } + + DEBUG("info", "Added record for $nick!$user\@$host to $serv" ); + return 0; +} + +# function called when data from child is available, or when child has ended, arguments and return value +sub my_hook_process_cb +{ + my ( $data, $command, $return_code, $out, $err ) = @_; + $hook_process = 0; + return weechat::WEECHAT_RC_OK; +} + +sub get_host_records { + # suppress output? yes|no + # type = host|nick, $query = name, $serv = server, @return = "." + my ( $suppress, $type, $query, $serv, @return ) = @_; + + $count = 0; %data = ( ); + my %data = _r_search( $suppress, $serv, $type, $query ); + for my $k ( keys %data ) { + DEBUG( "info", "$type query for records on $query from server $serv returned: $k" ); + push @return, $k if $data{$k} eq 'host'; + } + + # case-insensitive sort + return sort {uc($a) cmp uc($b)} @return; +} + +sub get_nick_records +{ + # type = host|nick, $query = nick, $serv = server, use_regex = 0|1, @return = "." + my ( $suppress, $type, $query, $serv, $use_regex, @return ) = @_; + + $count = 0; %data = ( ); + my %data = _r_search( $suppress, $serv, $type, $use_regex, ({ $type => $query }) ); + for my $k ( keys %data ) { + DEBUG( "info", "$type query for database records on $query from server $serv. returned: $k" ); + push @return, $k if $data{$k} eq 'nick'; + } + + if (lc($options{'normalize_nicks'}) eq "on" ) { + @return = normalize(@return); + } + + # case-insensitive sort + return sort {uc($a) cmp uc($b)} @return; +} + +sub _r_search { + my ( $suppress, $serv, $type, $use_regex, @input ) = @_; + + return %data if $count > 1000; + return %data if $count > $options{'max_recursion'}; + return %data if $count == 2 and ! $options{'recursive_search'}; + + DEBUG( "info", "Recursion Level: $count" ); + + if ( $type eq 'nick' ) { + $count++; + for my $row ( @input ) { + my $nick = $row->{nick}; + next if exists $data{$nick}; + + $data{$nick} = 'nick'; + my @hosts = _get_hosts_from_nick( $nick, $serv, $use_regex ); + # use regex only for nick search! + $use_regex = 0 if ( $use_regex ); + _r_search( $suppress, $serv, 'host', $use_regex, @hosts ); + } + } elsif ( $type eq 'host' ) { + $count++; + for my $row ( @input ) { + my $host = $row->{host}; + next if exists $data{$host}; + $data{$host} = 'host'; + my @nicks = _get_nicks_from_host( $host, $serv, $use_regex ); + next if (scalar(@nicks) <= 0); + + my $output_nicks; + if ( lc($options{'search_this_network_only'}) eq "on" ) + { + $output_nicks = join( ", ", map { $_->{nick} } @nicks ); + } + else { + $output_nicks = join( ", ", map { $_->{serv} . "." . $_->{nick} } @nicks ); + } + + my $ptr_buffer = weechat::current_buffer(); + + my $output = weechat::color('chat_prefix_network'). + weechat::prefix('network'). + weechat::color('chat_delimiters'). + "[". + weechat::color('chat_nick'). + $SCRIPT_NAME. + weechat::color('chat_delimiters'). + "] ". + weechat::color('reset'). + "Found nicks: $output_nicks". + " from host $host"; + + OUTPUT($ptr_buffer,$output) if ($suppress eq 'no'); + + # use regex only for host search! + $use_regex = 0 if ( $use_regex ); + _r_search( $suppress, $serv, 'nick', $use_regex, @nicks ); + } + } + return %data; +} + +sub _get_hosts_from_nick { + my ( $nick, $serv, $use_regex, @return ) = @_; + + my $sth; + + if ( lc($options{'search_this_network_only'}) eq "on" ) + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "SELECT nick, host FROM records WHERE nick REGEXP ? AND serv = ?" ); + $sth->execute( $nick, $serv ); + } + else + { + $sth = $DBH->prepare( "SELECT nick, host FROM records WHERE nick = ? COLLATE NOCASE AND serv = ?" ); + $sth->execute( $nick, $serv ); + } + } + else + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "SELECT nick, host, serv FROM records WHERE nick REGEXP ?"); + } + else + { + $sth = $DBH->prepare( "SELECT nick, host, serv FROM records WHERE nick = ? COLLATE NOCASE" ); + } + $sth->execute( $nick ); + } + # nothing found in database +# return '' if (not defined $sth->fetchrow_hashref); + return _ignore_guests( $sth ); +} + +sub _get_nicks_from_host { + my ( $host, $serv, $use_regex, @return ) = @_; + + my $sth; + if ( lc($options{'search_this_network_only'}) eq "on" ) + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "SELECT nick, host FROM records WHERE host REGEXP ? AND serv = ?" ); + $sth->execute( $host, $serv ); + } + else + { + $sth = $DBH->prepare( "SELECT nick, host FROM records WHERE host = ? AND serv = ?" ); + $sth->execute( $host, $serv ); + } + } + else + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "SELECT nick, host, serv FROM records WHERE host REGEXP ?" ); + } + else + { + $sth = $DBH->prepare( "SELECT nick, host, serv FROM records WHERE host = ?" ); + } + $sth->execute( $host ); + } + # nothing found in database +# return '' if (not defined $sth->fetchrow_hashref); + return _ignore_guests( $sth ); +} + +sub _ignore_guests +{ + my ( $sth ) = @_; + my @return; + + while ( my $row = $sth->fetchrow_hashref ) { + if ( lc($options{'ignore_guest_nicks'}) eq "on" ) { + my $regex = $options{'guest_nick_regex'}; + next if( $row->{nick} =~ m/$regex/i ); + } + if ( lc($options{'ignore_guest_hosts'}) eq "on" ) { + my $regex = $options{'guest_host_regex'}; + next if( $row->{host} =~ m/$regex/i ); + } + push @return, $row; + } + return @return; +} + +sub _deassociate_nick_from_host +{ + my ( $nick, $host, $serv, $use_regex, @return ) = @_; + + my $sth; + if ( lc($options{'search_this_network_only'}) eq "on" ) + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "DELETE FROM records WHERE host REGEXP ? AND nick REGEXP ? AND serv = ?" ); + } + else + { + $sth = $DBH->prepare( "DELETE FROM records WHERE host = ? AND nick = ? AND serv = ?" ); + } + $res = $sth->execute( $host, $nick, $serv ); + } + else + { + if ( $use_regex ) + { + $sth = $DBH->prepare( "DELETE FROM records WHERE host REGEXP ? AND nick REGEXP ?" ); + } + else + { + $sth = $DBH->prepare( "DELETE FROM records WHERE host = ? AND nick = ?" ); + } + $sth->execute( $host, $nick ); + } + return $sth->rows; +} + +# ------------------------[ OUTPUT with tags ]------------------------------ +sub OUTPUT +{ + my ($ptr_buffer,$output) = @_; + + if ( $options{'tags'} ne '' ) + { + weechat::print_date_tags($ptr_buffer,0,$options{'tags'},$output); + } + else + { + weechat::print($ptr_buffer,$output); + } +} +# -----------------------------[ debug ]----------------------------------- +sub DEBUG +{ + my $DEBUG_prefix; + my $color; + + if ( $_[0] eq 'info') + { + $DEBUG_prefix = 'info'; + $color = "default"; + } + elsif ( $_[0] eq 'error') + { + $DEBUG_prefix = weechat::config_string(weechat::config_get("weechat.look.prefix_error")); + $color = weechat::color(weechat::config_color(weechat::config_get("weechat.color.chat_prefix_error"))); + } + else + { + $DEBUG_prefix = '***'; + $color = 'default'; + } + weechat::print('', _color_str($color, $DEBUG_prefix) . "\t$SCRIPT_NAME: $_[1]") if (lc($options{debug}) eq 'on'); +} + +sub _color_str +{ + my ($color_name, $string) = @_; + # use eval for colors-codes (${color:red} eg in weechat.look.prefix_error) + $string = weechat::string_eval_expression($string, {}, {},{}) if ($weechat_version >= 0x00040200); + weechat::color($color_name) . $string . weechat::color('reset'); +} +# -------------------------------[ subroutines ]------------------------------------- +sub weechat_dir +{ + my $dir = $options{'db_name'}; + if ( $dir =~ /%h/ ) + { + my $weechat_dir = weechat::info_get( 'weechat_dir', ''); + $dir =~ s/%h/$weechat_dir/; + } + return $dir; +} +# -------------------------------[ main ]------------------------------------- +sub stalker_command_cb +{ + my ($data, $buffer, $args) = ($_[0], $_[1], $_[2]); + my @args_array=split(/ /,$args); + my $number = @args_array; + + return weechat::WEECHAT_RC_OK if ($number <= 0); + + if (lc($args_array[0]) eq 'count') + { + my $ptr_buffer = weechat::current_buffer(); + my ($count) = $DBH->selectrow_array("SELECT count(*) FROM records"); + my $output = weechat::color('chat_prefix_network'). + weechat::prefix('network'). + weechat::color('chat_delimiters'). + "[". + weechat::color('chat_nick'). + $SCRIPT_NAME. + weechat::color('chat_delimiters'). + "] ". + weechat::color('reset'). + "number of rows: ". + $count; + + OUTPUT($ptr_buffer,$output); + return weechat::WEECHAT_RC_OK; + } + # get localvar from current buffer + my $name = weechat::buffer_get_string(weechat::current_buffer(),'localvar_name'); + my $server = weechat::buffer_get_string(weechat::current_buffer(),'localvar_server'); + my $type = weechat::buffer_get_string(weechat::current_buffer(),'localvar_type'); + + if ( weechat::buffer_get_string(weechat::current_buffer(),'plugin') ne 'irc' and lc($args_array[0]) eq 'scan' ) + { + command_must_be_executed_on_irc_buffer(); + return weechat::WEECHAT_RC_OK; + } + + if (lc($args_array[0]) eq 'scan' && $type eq 'channel' && $number == 1) + { + channel_scan(weechat::current_buffer()); +# channel_scan_41(weechat::current_buffer()); + return weechat::WEECHAT_RC_OK; + } + + # at least, we have two arguments + return weechat::WEECHAT_RC_OK if ($number <= 1); + + my $use_regex = 0; + + if (lc($args_array[0]) eq 'scan' && $args_array[1] ne "") + { + $args_array[1] =~ s/\./,/; # info_get() needs an "," instead of "." + my $ptr_buffer = weechat::info_get('irc_buffer',$args_array[1]); +# channel_scan_41($ptr_buffer) if ( $ptr_buffer ne ""); + channel_scan($ptr_buffer) if ( $ptr_buffer ne ""); + } + elsif (lc($args_array[0]) eq 'nick' or lc($args_array[0]) eq 'host') + { + if ( defined $args_array[2] and $args_array[2] eq "-regex" ) + { + $use_regex = 1; + } + else + { + $server = $args_array[2] if ( defined $args_array[2] and $args_array[2] ne "" ); + } + + if ( defined $args_array[3] and $args_array[3] eq "-regex" ) + { + $use_regex = 1; + } + + if ( $server eq "" ) + { + command_must_be_executed_on_irc_buffer(); + return weechat::WEECHAT_RC_OK; + } + # $args_array[0]: 'nick' or 'host', $args_array[1]: nick or host name + my $nicks_found = join( ", ", (get_nick_records('no', $args_array[0], $args_array[1], $server, $use_regex))); + } + elsif (lc($args_array[0]) eq 'remove_nick_from_host') + { + $use_regex = 1 if ( grep{ $args_array[$_] eq '-regex' }0..$#args_array ); + + my $server = weechat::buffer_get_string(weechat::current_buffer(),'localvar_server'); + + if ( $server eq "" ) + { + command_must_be_executed_on_irc_buffer(); + return weechat::WEECHAT_RC_OK; + } + my $affected_rows = _deassociate_nick_from_host( $args_array[1], $args_array[2], $server, $use_regex ); + my $color = weechat::color(weechat::config_color(weechat::config_get('weechat.color.chat_prefix_error'))); + my $DEBUG_prefix = weechat::config_string(weechat::config_get('weechat.look.prefix_error')); + weechat::print('', _color_str($color, $DEBUG_prefix) . "\t$SCRIPT_NAME: $affected_rows deleted"); + } + return weechat::WEECHAT_RC_OK; +} + +sub command_must_be_executed_on_irc_buffer +{ + my $text = 'command must be executed on irc buffer (server or channel) or a server must be given'; + my $color = weechat::color(weechat::config_color(weechat::config_get('weechat.color.chat_prefix_error'))); + my $DEBUG_prefix = weechat::config_string(weechat::config_get('weechat.look.prefix_error')); + weechat::print('', _color_str($color, $DEBUG_prefix) . "\t$SCRIPT_NAME: $text"); +} +# hdata_search() +# hdata: hdata pointer +# pointer: pointer to a WeeChat/plugin object +# search: expression to evaluate, default pointer in expression is the name of hdata (and this pointer changes for each element in list); for help on expression, see command /eval in WeeChat User’s guide +# move: number of jump(s) to execute after unsuccessful search (negative or positive integer, different from 0) + +sub channel_scan_41 +{ + my $ptr_buffer = $_[0]; + + my $server_name = weechat::buffer_get_string($ptr_buffer, "localvar_server"); + my $channel_name = weechat::buffer_get_string($ptr_buffer, "localvar_channel"); + return if ($server_name eq "" or $channel_name eq ""); + +#my %hdata = { map { $_ => weechat::hdata_get( "irc_" . $_ ) } qw( server channel nick ) }; + my $hdata_server = weechat::hdata_get("irc_server"); + my $hdata_channel = weechat::hdata_get("irc_channel"); + my $hdata_nick = weechat::hdata_get("irc_nick"); + + my $ptr_server = weechat::hdata_search($hdata_server, weechat::hdata_get_list($hdata_server, 'irc_servers'), '${irc_server.name} == ' . $server_name, 1); + if ($ptr_server) + { + my $ptr_channel = weechat::hdata_search($hdata_channel, weechat::hdata_pointer($hdata_server, $ptr_server, 'channels'), '${irc_channel.name} == ' . $channel_name, 1); + + if ($ptr_channel) + { + my $nick = weechat::hdata_pointer($hdata_channel, $ptr_channel, 'nicks'); + while ( $nick ) + { + my $nick_name = weechat::hdata_string($hdata_nick, $nick, 'name'); + my $host_name = weechat::hdata_string($hdata_nick, $nick, 'host'); + $host_name =~ /(.*)\@/; + my $user_name = $1; + + add_record( $nick_name, $user_name, $host_name, $server_name); + + $nick = weechat::hdata_move($hdata_nick, $nick, 1); + } + } + + } +# weechat::print("",$ptr_buffer); +# weechat::print("",$server_name); + +# if ($ptr_servers) +# { +# my $channel = weechat::hdata_search(hdata['channel'], weechat.hdata_pointer(hdata['server'], server, 'channels'), '${irc_channel.name} == #test', 1) +# } +} +sub channel_scan +{ + my $ptr_buffer = $_[0]; + my $infolist = weechat::infolist_get('nicklist', $ptr_buffer, ''); + # don't stalk yourself + my $my_nick = weechat::buffer_get_string($ptr_buffer,'localvar_nick'); + + my $nick_counter; + + while (weechat::infolist_next($infolist)) + { + my $nick = weechat::infolist_string($infolist, 'name'); + if ((weechat::infolist_string($infolist, 'type') eq 'nick') + && ($nick ne $my_nick)) + { + my $ptr_nick = weechat::nicklist_search_nick($ptr_buffer, '', $nick); + my $localvar_server = weechat::buffer_get_string($ptr_buffer,'localvar_server'); + my $localvar_channel = weechat::buffer_get_string($ptr_buffer,'localvar_channel'); + + my $infolist_nick = weechat::infolist_get('irc_nick','',$localvar_server.','.$localvar_channel.','.$nick); + weechat::infolist_next($infolist_nick); + my $host = weechat::infolist_string($infolist_nick,'host'); + weechat::infolist_free($infolist_nick); + + next unless ($nick or $host or $localvar_server); + $host =~ /(.*)\@/; + $user = $1; + + add_record( $nick, $user, $host, $localvar_server); + +# $user=~ s/[\Q-_~^`\E]//g; +# my $hdata = weechat::hdata_get("irc_nick"); +# my $hdata_host = weechat::hdata_string($hdata, $ptr_nick, "host"); +# next if ($host eq $name); + + } + } + weechat::infolist_free($infolist); +} + +# simple check for last nick/host +# to prevent multiple requests (e.g. "/nick|join nick" for several channels!) +# 0 = failed +# 1 = found +sub check_last_nick_host +{ + my ($nick,$host) = @_; + my $rc = 0; + + $rc = 1 if ($nick eq $last_nick && $host eq $last_host); + + $last_nick = $nick; + $last_host = $host; + return $rc; +} +# -------------------------------[ hooks ]------------------------------------- +# :old_nick!~user@host NICK :new_nick +# /NICK command called +# this is a server command +sub irc_in2_nick_cb +{ + my ($signal, $callback, $callback_data) = @_; + my ($server,undef) = split(',',$callback); + + return weechat::WEECHAT_RC_OK if ( lc($options{'ignore_nickchange'}) eq "on" ); + + my $hashtable = weechat::info_get_hashtable("irc_message_parse" => + { "message" => $callback_data }); + + # $old_nick = $hashtable->{nick} + my ($old_nick, $host) = split('!', $hashtable->{host}); + my $nick = $hashtable->{arguments}; + $nick =~ s/^.//; # remove leading ":" + my ($user,undef) = split("@",$host); + + return weechat::WEECHAT_RC_OK if check_last_nick_host($nick,$host); + + add_record( $nick, $user, $host, $server); + + return weechat::WEECHAT_RC_OK; +} + +sub irc_in2_whois_cb +{ + my ($signal, $callback, $callback_data) = @_; + my ($server,undef) = split(',',$callback); + + my $ptr_buffer = ''; + + my (undef, undef, undef, $nick, $user, $host, undef) = split(' ', $callback_data); + my $msgbuffer_whois = weechat::config_string(weechat::config_get('irc.msgbuffer.whois')); + + # check for nick_regex + if ( lc($options{'ignore_guest_nicks'}) eq "on" ) + { + my $regex = $options{'guest_nick_regex'}; + return weechat::WEECHAT_RC_OK if( $nick =~ m/$regex/i ); + } + + my $complete_host = $user."@".$host; + + unless ( check_last_nick_host($nick,$complete_host) or lc($options{'ignore_whois'}) eq "on" ) + { + add_record( $nick, $user, $complete_host, $server); + } + + # output for /whois + if ($msgbuffer_whois eq 'server') + { + $ptr_buffer = weechat::info_get('irc_buffer',$server); +# $ptr_buffer = weechat::buffer_search('irc', 'server.' . $server); + } + elsif ($msgbuffer_whois eq 'weechat') + { + $ptr_buffer = weechat::buffer_search_main(); + } + elsif ($msgbuffer_whois eq 'current') + { + $ptr_buffer = weechat::current_buffer(); + } + elsif ($msgbuffer_whois eq 'private') + { + $ptr_buffer = weechat::info_get('irc_buffer',$server.','.$nick); + if ($ptr_buffer eq '') + { + $msgbuffer_whois = weechat::config_string(weechat::config_get('irc.look.msgbuffer_fallback')); + $ptr_buffer = weechat::info_get('irc_buffer', $server) if ($msgbuffer_whois eq 'server'); + } + } + + my $use_regex = 0; + my $nicks_found = join( ", ", (get_nick_records('yes', 'nick', $nick, $server, $use_regex))); + + # only the given nick is returned? + return weechat::WEECHAT_RC_OK if ($nicks_found eq $nick); + + # more than one nick was returned from sqlite + my $prefix_network = weechat::prefix('network'); + my $color_chat_delimiter = weechat::color('chat_delimiters'); + my $color_chat_nick = weechat::color('chat_nick'); + + my $output = weechat::color('chat_prefix_network'). + weechat::prefix('network'). + weechat::color('chat_delimiters'). + "[". + weechat::color('chat_nick'). + $SCRIPT_NAME. + weechat::color('chat_delimiters'). + "] ". + $nicks_found; + + # fallback buffer.. + $ptr_buffer = weechat::buffer_search_main() unless ($ptr_buffer); + + # print /WHOIS with [stalker] line + OUTPUT($ptr_buffer,$output); + + return weechat::WEECHAT_RC_OK; +} + +# callback_data: :nick!~user_2@host JOIN #channel +sub irc_in2_join_cb +{ + my ($signal, $callback, $callback_data) = @_; + my ($server,$irc_signal) = split(',',$callback); + my ($nick,$host,$channel) = ($callback_data =~ /\:(.*)\!(.*) JOIN (.*)/); + + $host =~ /(.*)\@/; + my $user = $1; + + my $ptr_buffer = weechat::info_get('irc_buffer',$server . ',' . $channel); + return weechat::WEECHAT_RC_OK unless ($ptr_buffer); +# my $ptr_buffer = weechat::buffer_search('irc', $server . '.' . $channel); + + my $my_nick = weechat::buffer_get_string($ptr_buffer,'localvar_nick'); + # don't stalk yourself + return weechat::WEECHAT_RC_OK if ($nick eq $my_nick); + + return weechat::WEECHAT_RC_OK if check_last_nick_host($nick,$host); + + # check for localvar "stalker" + if ( lc($options{'use_localvar'}) eq "on" ) + { + return weechat::WEECHAT_RC_OK if (not weechat::config_string_to_boolean(weechat::buffer_get_string($ptr_buffer, 'localvar_stalker')) ); + } + + add_record( $nick, $user, $host, $server); + + return weechat::WEECHAT_RC_OK; +} + +# -----------------------------[ config ]----------------------------------- +sub init_config{ + + foreach my $option (keys %options){ + if (!weechat::config_is_set_plugin($option)){ + weechat::config_set_plugin($option, $options{$option}); + } + else{ + $options{$option} = weechat::config_get_plugin($option); + } + } + # set help text for options + if ( ($weechat_version ne '') && (weechat::info_get('version_number', '') >= 0x00030500) ) { # v0.3.5 + foreach my $desc_options (keys %desc_options) + { + weechat::config_set_desc_plugin($desc_options,$desc_options{$desc_options}); + } + } + +} + +sub toggle_config_by_set +{ + my ($pointer, $name, $value) = @_; + $name = substr($name, length("plugins.var.perl.$SCRIPT_NAME."), length($name)); + $options{$name} = $value; +# insert a refresh here + return weechat::WEECHAT_RC_OK; +} + +# -------------------------------[ init ]------------------------------------- +# first function called by a WeeChat-script. +weechat::register($SCRIPT_NAME, $SCRIPT_AUTHOR, $SCRIPT_VERSION, + $SCRIPT_LICENCE, $SCRIPT_DESC, '', ''); + + $weechat_version = weechat::info_get('version_number', ''); + + if ( ($weechat_version ne '') && (weechat::info_get('version_number', '') <= 0x00030400) ) + { + OUTPUT('',weechat::prefix('error') . 'You need WeeChat >= 0.3.4. Visit: www.weechat.org'); + weechat::command('',"/wait 1ms /perl unload $SCRIPT_NAME"); + } + else + { + init_config(); + open_database(); + + weechat::hook_command($SCRIPT_NAME, $SCRIPT_DESC, "host [server] [-regex] || nick [server] [-regex] || scan [] || count", + " host : look for hostname\n". + " nick : look for nick\n". + " scan : scan a channel (be careful; scanning large channels takes a while!)\n". + " you should manually /WHO #channel first or use /quote PROTOCTL UHNAMES\n". + " count: display the number of rows in database\n". + "remove_nick_from_host: remove a nick from a given host\n". + "\n\n". + "Stalker will add nick!user\@host to database monitoring JOIN/WHOIS/NICK messages.\n\n". + "\n". + "Monitor specific channels:\n". + "==========================\n". + "Set following option:\n". + " /set plugins.var.perl.".$SCRIPT_NAME.".use_localvar \"on\" (default: off)\n". + "Now you'll have to set a localvar for those channels to monitor:\n". + " /buffer set localvar_set_stalker [value]\n". + " values: \"on\", \"true\", \"t\", \"yes\", \"y\", \"1\")\n". + "\n". + "Regex:\n". + "======\n". + "$SCRIPT_NAME performs standard perl regular expression matching with option '-regex'.\n". + "Note that regex matching will not use SQLite indices, but will iterate over all rows, so it could be quite costly in terms of performance.\n". + "\n". + "Tags:\n". + "======\n". + $SCRIPT_NAME." can use tags to display messages. See documentation for most commonly used tags and add them in following option:\n". + " /set plugins.var.perl.".$SCRIPT_NAME.".tags \"no_log\"\n". + "\n". + "Examples:\n". + " search for nick 'nils_2'\n". + " /".$SCRIPT_NAME." nick nils_2\n". + " search for nick 'nils_2' on a different server named 'unknown'\n". + " /".$SCRIPT_NAME." nick nils_2 unknown\n". + " search for nicks starting with 'ni'\n". + " /".$SCRIPT_NAME." nick \\bni.* -regex\n". + " search all hosts located in '.de'\n". + " /".$SCRIPT_NAME." host .*\\.de -regex\n". + " remove nick from an association host'\n". + " /".$SCRIPT_NAME." remove_nick_from_host TheNick ~the\@bad.users.host\n". + "", + "count %-||". + "host %% %(irc_servers)|-regex %-||". + "nick %(nick) %(irc_servers)|-regex -regex %-||". + "remove_nick_from_host %(nick) |-regex -regex %-||". + "scan %(buffers_names) %-", "stalker_command_cb", ""); + + weechat::hook_config("plugins.var.perl.$SCRIPT_NAME.*", "toggle_config_by_set", ""); + weechat::hook_signal('*,irc_in2_join', 'irc_in2_join_cb', ''); + weechat::hook_signal('*,irc_in2_311', 'irc_in2_whois_cb', ''); + weechat::hook_signal('*,irc_in2_NICK', 'irc_in2_nick_cb', ''); + } diff -Nru weechat-scripts-20130123/perl/sysinfo.pl weechat-scripts-20131007/perl/sysinfo.pl --- weechat-scripts-20130123/perl/sysinfo.pl 2013-01-23 19:00:25.000000000 +0000 +++ weechat-scripts-20131007/perl/sysinfo.pl 2013-10-07 12:14:56.000000000 +0000 @@ -38,9 +38,12 @@ # You can also reach Travis in #crd on efnet. # # ported to WeeChat (http://www.weechat.org/) by Nils Görs. Copyright -# (c) 2011-2012 Nils Görs -# +# (c) 2011-2013 Nils Görs # +# 2013-08-10: 0.7 nils_2 (freenode@nils_2) +# : add: support of vcgencmd (eg raspberry pi) +# 2013-03-06: 0.6 Thomas Poechtrager +# : fixed memory usage # 2012-11-15: 0.5 nils_2 (freenode@nils_2) # : based on sysinfo 2.81.21 # : bug with "armv5tel" in sysinfo 2.81.21 fixed (Version bumped to 2.81.22 and sent to maintainer) @@ -63,7 +66,7 @@ use strict; my $SCRIPT_NAME = "sysinfo"; -my $SCRIPT_VERSION = "0.5"; +my $SCRIPT_VERSION = "0.7"; my $SCRIPT_DESCR = "provides a system info command"; my $SCRIPT_LICENSE = "GPL3"; my $SCRIPT_AUTHOR = "Nils Görs "; @@ -173,7 +176,7 @@ my $bar_item = ""; my %Hooks = (); my $weechat_version = ""; - +my $vcgencmd = "/usr/bin/vcgencmd"; ############################################### ### Nothing below here should need changed. ### ############################################### @@ -541,6 +544,15 @@ } if($arm) { $cpu = &cpuinfo("Processor\\s+: "); + if (-e $vcgencmd) { + $mhz = `vcgencmd measure_clock arm`; + $mhz = substr($mhz,length($mhz) - (length($mhz)-index($mhz,")=")-2)) / 1000000; + my $temp = `vcgencmd measure_temp`; + $temp =~ tr/\r\n//d; + $temp = substr($temp,5); + $cpu = "$cpu ($mhz MHz / $temp)"; + } + } if($i686 || $i586 || $x86_64) { $cpu = &cpuinfo("model name\\s+: "); @@ -805,10 +817,10 @@ $vard = `vmstat -s | grep 'pages active' | awk '{print \$1}'` * `vmstat -s | grep 'per page' | awk '{print \$1}'`; $vara = `$sysctl -n hw.physmem`; } - $varp = sprintf("%.2f", $vard / $vara * 100); + $varp = sprintf("%.2f", 100-($vard / ($vara-$vard) * 100)); $vara = sprintf("%.2f", $vara / 1024 / 1024); $vard = sprintf("%.2f", $vard / 1024 / 1024); - return $vard."MB/".$vara."MB ($varp%)"; + return ($vara-$vard)."MB/".$vara."MB ($varp%)"; } sub networkinfobsd { diff -Nru weechat-scripts-20130123/perl/unset_unused.pl weechat-scripts-20131007/perl/unset_unused.pl --- weechat-scripts-20130123/perl/unset_unused.pl 2013-01-23 19:00:25.000000000 +0000 +++ weechat-scripts-20131007/perl/unset_unused.pl 2013-10-07 12:14:57.000000000 +0000 @@ -1,5 +1,5 @@ # -# Copyright (c) 2011 by Nils Görs +# Copyright (c) 2011-2013 by Nils Görs # # unset script option(s) from not installed scripts # @@ -16,12 +16,18 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# +# 13-07-27: 0.2 : added: support for guile_script +# # 11-08-28: 0.1 # +# Development is currently hosted at +# https://github.com/weechatter/weechat-scripts + use strict; my $PRGNAME = "unset_unused"; -my $VERSION = "0.1"; +my $VERSION = "0.2"; my $AUTHOR = "Nils Görs "; my $LICENCE = "GPL3"; my $DESCR = "unset script option(s) from not installed scripts (YOU ARE USING THIS SCRIPT AT YOUR OWN RISK!)"; @@ -33,53 +39,70 @@ "ruby" => "ruby_script", "tcl" => "tcl_script", "lua" => "lua_script", + "guile" => "guile_script", ); -my $flag = 0; my $option_struct; my %option_struct; my $str; -sub get_scripts{ - foreach my $script (values %script_plugins){ +# get installed scripts +sub get_scripts +{ + foreach my $script (values %script_plugins) + { my $infolist = weechat::infolist_get($script,"",""); - while (weechat::infolist_next($infolist)){ - my $script_name = weechat::infolist_string($infolist, "name"); - $str .= $script_name . "|"; + while (weechat::infolist_next($infolist)) + { + my $script_name = weechat::infolist_string($infolist, "name"); + $str .= $script_name . "|"; } - weechat::infolist_free($infolist); + weechat::infolist_free($infolist); } } -sub get_options{ - my $number = 0; +sub get_options +{ + # $flag: 0 = list; 1 = unset options + my ( $flag, $count ) = ( $_[0], $_[1] ); my $key; + my $number = 0; chop($str); - foreach my $plugin (keys %script_plugins){ + foreach my $plugin (keys %script_plugins) + { my $infolist = weechat::infolist_get("option","","plugins.var.$plugin.*"); - while (weechat::infolist_next($infolist)){ + while (weechat::infolist_next($infolist)) + { my $option_name = weechat::infolist_string($infolist, "option_name"); my $full_name = weechat::infolist_string($infolist, "full_name"); (undef,$option_name,undef) = split(/\./, $option_name); $option_struct->{"full_name"} = $full_name; - while ( my ($key,$value) = each %$option_struct ){ - if ( index($value, "check_license") == -1) { - if( not $value =~ m/($str)/i){ - weechat::print("",$value) if ( $flag == 0 ); - if ( $flag == 1 ){ - weechat::command("","/mute unset $value"); - if ($weechat_version >= 0x00030600){ - my $name = substr($value, length("plugins.var."), length($value)); - weechat::command("","/mute unset plugins.desc.$name"); - } - } + while ( my ($key,$value) = each %$option_struct ) + { + if ( index($value, "check_license") == -1) + { + if( not $value =~ m/($str)/i) + { + $number ++; + weechat::print("",$value) if ( $flag == 0 ); # list options + if ( $flag == 1 ) # remove options + { + weechat::print("",$number . "/" . $count . " deleted... " .$value); +# weechat::command("","/mute unset $value"); +# if ($weechat_version >= 0x00030600) +# { +# my $name = substr($value, length("plugins.var."), length($value)); +# weechat::command("","/mute unset plugins.desc.$name"); +# } + } } } } } weechat::infolist_free($infolist); } + return $number; } # delete double entries @@ -95,15 +118,18 @@ get_scripts(); - if ( $getargs eq "list"){ - $flag = 0; + if ( $getargs eq "list") + { weechat::print("","unused script options:"); - get_options(); - }elsif ($getargs eq "unset"){ - $flag = 1; - get_options(); + my $count = get_options(0,0); + weechat::print("","Number of unused options: $count") if ( $count > 0 ); + } + elsif ($getargs eq "unset") + { + my $count = get_options(0,0); + get_options(1,$count); } -return weechat::WEECHAT_RC_OK +return weechat::WEECHAT_RC_OK } # -------------------------------[ init ]------------------------------------- # first function called by a WeeChat-script. diff -Nru weechat-scripts-20130123/perl/url_arza.pl weechat-scripts-20131007/perl/url_arza.pl --- weechat-scripts-20130123/perl/url_arza.pl 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/perl/url_arza.pl 2013-10-07 12:14:59.000000000 +0000 @@ -0,0 +1,79 @@ +# Url shortener for WeeChat by arza , distributed freely and without any warranty, licensed under GPL3 + +# Why yet another url shortener script? +# - use your own shortener in a web server, for example: http://weechat.arza.us/url_arza.php +# - a key to shorten url in input line: bind to /url_arza +# - toggle short urls under long urls, not logged: /filter add url_arza * no_log ^^http:// ; /filter toggle url_arza +# - no dependencies +# - simple + +# Requires WeeChat >=0.3.6 + +weechat::register('url_arza', 'arza ', '0.1', 'GPL3', 'Shorten long urls in buffers and input line', '', ''); +weechat::hook_print('', 'notify_message', '://', 0, 'url_in', ''); +weechat::hook_command('url_arza', 'Shorten url in input line', '', '', '', 'command', ''); +weechat::hook_config('plugins.var.perl.url_arza.*', 'set', ''); + +my %settings; + +for( + [ 'url', 'http://arza.us/s/?password=&url=', 'url for shortener, url to shorten is appended, the shortener should return the short url' ], + [ 'url_append_command', '&id_min_length=1', 'string to append to the url when shortening in input line' ], + [ 'url_append_incoming', '&id_min_length=2', 'string to append to the url when shortening incoming urls' ], + [ 'min_length', 100, 'minimum length for incoming urls to shorten, after http://' ], +){ my ($name, $value, $description) = @$_; + if(weechat::config_is_set_plugin($name)){ + $settings{$name}=weechat::config_get_plugin($name); + }else{ + weechat::config_set_plugin($name, $value); + weechat::config_set_desc_plugin($name, "$description (default: $value)"); + } +} + +my $timeout=2000; +my $delimiter="^\t"; + + +sub escape { my $url=$_[0]; + $url=~s/([^a-zA-Z0-9_.~-])/sprintf('%%%02x',ord($1))/eg; + return $url; +} + + +sub command { my $buffer=$_[1]; + my $input=weechat::buffer_get_string($buffer, 'input'); + ( my ($long) = $input=~/(https?:\/\/\S+)$/ ) || return weechat::WEECHAT_RC_OK; + weechat::hook_process("url:$settings{url}".escape($long).$settings{'url_append_command'}, $timeout, 'command_fetch', "$buffer $long $input"); + return weechat::WEECHAT_RC_OK; +} + +sub command_fetch { $_[2] && return weechat::WEECHAT_RC_ERROR; + my ($buffer, $long, $input) = split(/ /, $_[0], 3); + my $short=$_[3]; + my $input_pos=weechat::buffer_get_integer($buffer, 'input_pos') + length($short) - length($long); + $input=~s/\Q$long\E$/$short/; + weechat::buffer_set($buffer, 'input', $input); + weechat::buffer_set($buffer, 'input_pos', $input_pos); + return weechat::WEECHAT_RC_OK; +} + + +sub url_in { my ($buffer, $displayed, $prefix, $line) = ($_[1], $_[4], $_[6], $_[7]); + $displayed && ( my ($long) = $line=~/(https?:\/\/\S{$settings{'min_length'},})/ ) || return weechat::WEECHAT_RC_OK; + weechat::hook_process("url:$settings{url}".escape($long).$settings{'url_append_incoming'}, $timeout, 'url_in_fetch', "$buffer $prefix"); + return weechat::WEECHAT_RC_OK; +} + +sub url_in_fetch { $_[2] && return weechat::WEECHAT_RC_ERROR; + my ($buffer, $prefix) = split(/ /, $_[0], 2); + my $short=$_[3]; + weechat::print_date_tags($buffer, 0, 'no_log', ' ' x length(weechat::string_remove_color($prefix, '')) . $delimiter . $short); + return weechat::WEECHAT_RC_OK; +} + + +sub set { + $settings{substr($_[1], length('plugins.var.perl.url_arza.'))}=$_[2]; + return weechat::WEECHAT_RC_OK; +} + diff -Nru weechat-scripts-20130123/python/allquery.py weechat-scripts-20131007/python/allquery.py --- weechat-scripts-20130123/python/allquery.py 2013-01-23 19:00:15.000000000 +0000 +++ weechat-scripts-20131007/python/allquery.py 2013-10-07 12:14:47.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2011 by F. Besser +# Copyright (c) 2011-2013 by F. Besser # # 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 @@ -15,10 +15,14 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # - -# # # History: +# 2013-09-01, nils_2@freenode.#weechat: +# version 0.2: add support of servername for "-exclude" +# : make script behave like /allchan and /allserver command +# : add function "-current" +# : case-insensitive search for query/server +# # 2011-09-05, F. Besser : # version 0.1: script created # @@ -31,7 +35,7 @@ SCRIPT_NAME = "allquery" SCRIPT_AUTHOR = "fbesser" -SCRIPT_VERSION = "0.1" +SCRIPT_VERSION = "0.2" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Executes command on all irc query buffer" @@ -55,7 +59,7 @@ def make_list(argument): """ Make a list out of argument string of format -argument=value0,value1""" - arglist = argument.split("=", 1) + arglist = argument.lower().split("=", 1) arguments = arglist[1].split(",") return arguments @@ -68,16 +72,33 @@ argv = args.split(" ") exclude_nick = None + current_server = None - if argv[0].startswith("-exclude="): - exclude_nick = make_list(argv[0]) - command = " ".join(argv[1::]) + if '-current' in argv: + current_server = weechat.buffer_get_string(weechat.current_buffer(), "localvar_server") + # remove "-current" + whitespace from argumentlist + args = args.replace("-current", "") + args = args.lstrip() + argv.remove("-current") + + # search for "-exclude" in arguments + i = 0 + for entry in argv[0:]: + if entry.startswith("-exclude="): + exclude_nick = make_list(argv[i]) + command = " ".join(argv[i+1::]) + break + i +=1 else: command = args - if not command.startswith("/"): - weechat.command("", "/help %s" % SCRIPT_COMMAND) + + # no command found. + if not command: return weechat.WEECHAT_RC_OK + if not command.startswith("/"): + command = "/%s" % command + infolist = weechat.infolist_get("buffer", "", "") while weechat.infolist_next(infolist): if weechat.infolist_string(infolist, "plugin_name") == "irc": @@ -86,31 +107,44 @@ query = weechat.buffer_get_string(ptr, "localvar_channel") execute_command = re.sub(r'\$nick', query, command) if weechat.buffer_get_string(ptr, "localvar_type") == "private": - if exclude_nick is not None: - if not query in exclude_nick: - weechat.command(ptr, execute_command) + if current_server is not None: + if server == current_server: + exclude_nick_and_server(ptr,query,server,exclude_nick,execute_command) else: - weechat.command(ptr, execute_command) + exclude_nick_and_server(ptr,query,server,exclude_nick,execute_command) weechat.infolist_free(infolist) return weechat.WEECHAT_RC_OK + +def exclude_nick_and_server(ptr, query, server, exclude_nick, execute_command): + server = "%s.*" % server # servername + ".*" + if exclude_nick is not None: + if not query.lower() in exclude_nick and not server.lower() in exclude_nick: + weechat.command(ptr, execute_command) + else: + weechat.command(ptr, execute_command) + + if __name__ == '__main__' and import_ok: if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "", ""): weechat.hook_command(SCRIPT_COMMAND, SCRIPT_DESC, - '[-exclude=,[...]] command ', - ' -exclude=nick1,...: exclude some querys from executed command\n' - ' command: command executed in query buffers\n' - ' $nick: gets replaced by query buffer nick\n\n' + '[-current] [-exclude=[,...]] []', + ' -current: execute command for query of current server only\n' + ' -exclude: exclude some querys and/or server from executed command\n' + ' command: command executed in query buffers\n' + ' arguments: arguments for command (special variables $nick will be replaced by its value)\n\n' 'Examples:\n' ' close all query buffers:\n' - ' /' + SCRIPT_COMMAND + ' /buffer close\n' + ' /' + SCRIPT_COMMAND + ' buffer close\n' ' close all query buffers, but don\'t close FlashCode:\n' - ' /' + SCRIPT_COMMAND + ' -exclude=FlashCode /buffer close\n' + ' /' + SCRIPT_COMMAND + ' -exclude=FlashCode buffer close\n' + ' close all query buffers, except for server freenode:\n' + ' /' + SCRIPT_COMMAND + ' -exclude=freenode.* buffer close\n' ' msg to all query buffers:\n' - ' /' + SCRIPT_COMMAND + ' /say Hello\n' + ' /' + SCRIPT_COMMAND + ' say Hello\n' ' notice to all query buffers:\n' - ' /' + SCRIPT_COMMAND + ' /notice $nick Hello', - '', + ' /' + SCRIPT_COMMAND + ' notice $nick Hello', + '%(commands)', 'allquery_command_cb', '') diff -Nru weechat-scripts-20130123/python/alternatetz.py weechat-scripts-20131007/python/alternatetz.py --- weechat-scripts-20130123/python/alternatetz.py 2013-01-23 19:00:10.000000000 +0000 +++ weechat-scripts-20131007/python/alternatetz.py 2013-10-07 12:14:42.000000000 +0000 @@ -1,43 +1,57 @@ # -*- coding: utf-8 -*- # -# Chmouel Boudjnah +# Copyright (C) 2010 Chmouel Boudjnah +# Copyright (C) 2012-2013 bwidawsk # License: GPL3 # -''' -Display Different time in buffer. -Just put [alternatetz] on your bar items to add it. -''' +# plugin to get alternate timezones in a weechat bar +# +# Changelog: +# 0.2 Added help, and multiple timezeones +# 0.1 first version +# + import weechat as w import pytz import datetime SCRIPT_NAME = "alternatetz" SCRIPT_AUTHOR = "Chmouel Boudjnah " -SCRIPT_VERSION = "0.1" +SCRIPT_VERSION = "0.2" SCRIPT_LICENSE = "GPL3" -SCRIPT_DESC = "Display Alternate Time from different TimeZone" +SCRIPT_DESC = "Display Alternate Time from different Timezones" -# script options -settings = { - "timezone" : 'US/Central', - "timeformat" : "%H:%M", +SCRIPT_COMMAND = 'alternatetz' + +OPTIONS = { +'timezone' : ('GMT', 'list of timezones to display. The list is comprised of space separated list timezones using the Olson tz database'), +'timeformat' : ('%H:%M', 'strftime compatible format') } def alternatetz_item_cb(*kwargs): - tzname = w.config_get_plugin('timezone') - tz = pytz.timezone(tzname) - return datetime.datetime.now(tz).strftime(w.config_get_plugin('timeformat')) + ret = '' + tznames = OPTIONS['timezone'].split() + for tzname in tznames: + tz = pytz.timezone(tzname) + ret += tz.zone + ': ' + datetime.datetime.now(tz).strftime(OPTIONS['timeformat']) + ' ' + return ret[:-1] def alternatetz_timer_cb(*kwargs): w.bar_item_update('alternatetz') return w.WEECHAT_RC_OK - -if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, - SCRIPT_DESC, '', ''): - for option, default_value in settings.iteritems(): + +if __name__ == '__main__': + w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', '') + for option,value in list(OPTIONS.items()): + w.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) if not w.config_is_set_plugin(option): - w.config_set_plugin(option, default_value) + w.config_set_plugin(option, value[0]) + OPTIONS[option] = value[0] + else: + OPTIONS[option] = w.config_get_plugin(option) w.bar_item_new('alternatetz', 'alternatetz_item_cb', '') w.bar_item_update('alternatetz') w.hook_timer(1000*60, 60, 0, 'alternatetz_timer_cb', '') + +# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4 diff -Nru weechat-scripts-20130123/python/away_action.py weechat-scripts-20131007/python/away_action.py --- weechat-scripts-20130123/python/away_action.py 2013-01-23 19:00:11.000000000 +0000 +++ weechat-scripts-20131007/python/away_action.py 2013-10-07 12:14:43.000000000 +0000 @@ -40,6 +40,8 @@ # # # History: +# 2013-05-18: +# version 0.4: add include_channel option - contributed by Atluxity # 2010-11-04: # version 0.3: minor cleanups, fix import, add hook info # 2010-03-17: @@ -51,7 +53,7 @@ SCRIPT_NAME = "away_action" SCRIPT_AUTHOR = "xt " -SCRIPT_VERSION = "0.3" +SCRIPT_VERSION = "0.4" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Run command on highlight and privmsg when away" @@ -62,6 +64,7 @@ 'ignore_text' : '', 'command' : '/mute msg ', # Command to be ran, nick and message will be inserted at the end 'force_enabled' : 'off', +'include_channel': 'off', # Option to include channel in insert after command. } ignore_nick, ignore_text, ignore_channel = (), (), () @@ -139,7 +142,11 @@ w.prnt('', '%s: Error: %s' %(SCRIPT_NAME, 'command must start with /')) return WEECHAT_RC_OK - w.command('', '%s <%s> %s' %(command, prefix, msg)) + if 'channel' in locals() and \ + w.config_get_plugin('include_channel') == 'on': + w.command('', '%s @%s <%s> %s' %(command, channel, prefix, msg)) + else: + w.command('', '%s <%s> %s' %(command, prefix, msg)) return WEECHAT_RC_OK def ignore_update(*args): diff -Nru weechat-scripts-20130123/python/bitlbee_typing_notice.py weechat-scripts-20131007/python/bitlbee_typing_notice.py --- weechat-scripts-20130123/python/bitlbee_typing_notice.py 2013-01-23 19:00:11.000000000 +0000 +++ weechat-scripts-20131007/python/bitlbee_typing_notice.py 2013-10-07 12:14:43.000000000 +0000 @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- # # Copyright (c) 2010 by Alexander Schremmer +# Copyright (c) 2013 by Corey Halpin # # 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 @@ -17,78 +18,89 @@ # # -# (this script requires WeeChat 0.3.0 or newer) +# (this script requires WeeChat 0.3.6 or newer) # # History: +# 2013-06-24, Priska Herger +# version 0.4: bug fix: if TYPING 0, don't show typing. +# 2013-04-27, Corey Halpin +# version 0.3: +# * Use irc_message_parse to extract nicks +# * Send typing = 0 at message completion in private buffers +# * Make server, channel, and timeout configurable w/o editing plugin code. # 2010-05-20, Alexander Schremmer # version 0.2: also handle users that do not send a TYPING 0 msg before quitting # removed InfoList code # 2010-05-16, Alexander Schremmer # version 0.1: initial release + +# Configuration options via /set: +# +# 'channel' +# description: Name of your bitlbee channel +# command: /set plugins.var.python.bitlbee_typing_notice.channel &bitlbee +# +# 'server' +# description: Server running your bitlbee instance. +# command: /set plugins.var.python.bitlbee_typing_notice.server localhost +# +# 'timeout' +# description: Send "not typing" after this many seconds w/o typing. +# command: /set plugins.var.python.bitlbee_typing_notice.timeout 4 +# +# Note, the plugin must be reloaded after either of these settings are changed. +# /python reload works for this. + + import weechat as w import re SCRIPT_NAME = "bitlbee_typing_notice" SCRIPT_AUTHOR = "Alexander Schremmer " -SCRIPT_VERSION = "0.2" +SCRIPT_VERSION = "0.4" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Shows when somebody is typing on bitlbee and sends the notice as well" +typing = {} # Record nicks who sent typing notices. key = subject nick, val = typing level. -bitlbee_channel = "&bitlbee" -bitlbee_server_name = "bitlbee" - -KEEP_TYPING_TIMEOUT = 1 -STOP_TYPING_TIMEOUT = 7 - -typing = {} -sending_typing = {} - +sending_typing = {} # Nicks to whom we're sending typing notices. +# key = target nick, val = sequence number used to determine when the typing notice +# should be removed. def channel_has_nick(server, channel, nick): buffer = w.buffer_search("", "%s.%s" % (server, channel)) return bool(w.nicklist_search_nick(buffer, "", nick)) - -def redraw(nick): - w.bar_item_update("bitlbee_typing_notice") - - +# Callback which checks for ctcp typing notices sent to us. +# Updates typing data, hides the ctcp notices. def ctcp_cb(data, modifier, modifier_data, string): - if modifier_data != bitlbee_server_name: + if modifier_data != w.config_get_plugin("server"): return string - match = re.match(r'(.*) PRIVMSG (.*)', string) + msg_hash = w.info_get_hashtable( + "irc_message_parse", {"message": string} ) + if msg_hash["command"] != "PRIVMSG": + return string + match = re.search('\001TYPING ([0-9])\001', msg_hash["arguments"]) if match: - host, msg = match.groups() - match = re.search('\001TYPING ([0-9])\001', msg) - if match: - nick = re.match(':(?P.+)!', string).groups()[0] - typing_level = int(match.groups()[0]) - if typing_level == 0: - try: - del typing[nick] - except KeyError: - pass - redraw(nick) - elif typing_level == 1: - typing[nick] = 1 - # XXX add ICQ/Yahoo hack - redraw(nick) - elif typing_level == 2: - typing[nick] = 2 - redraw(nick) - return "" - return string - buffer = w.buffer_search("", "%s.%s" % (server, channel)) + nick = msg_hash["nick"] + typing_level = int(match.groups()[0]) + if typing_level == 0 and nick in typing: + del typing[nick] + elif typing_level > 0: + typing[nick] = typing_level + w.bar_item_update("bitlbee_typing_notice") + return "" + else: + return string + def stop_typing(data, signal, signal_data): - nick = re.match(':(?P.+)!', signal_data).groups()[0] - try: - del typing[nick] - except KeyError: - pass - redraw(nick) + msg_hash = w.info_get_hashtable( + "irc_message_parse", {"message": signal_data } ) + if msg_hash["nick"] in typing: + del typing[msg_hash["nick"]] + w.bar_item_update("bitlbee_typing_notice") return w.WEECHAT_RC_OK def typed_char(data, signal, signal_data): @@ -98,41 +110,52 @@ channel = w.buffer_get_string(buffer, 'localvar_channel') buffer_type = w.buffer_get_string(buffer, 'localvar_type') - if server != bitlbee_server_name or input_s.startswith("/"): + if server != w.config_get_plugin("server") or input_s.startswith("/"): return w.WEECHAT_RC_OK if buffer_type == "private": - if input_s: + if len(input_s)==0: + send_typing(channel, 0) # Line sent or deleted -- no longer typing + else: send_typing(channel, 1) - elif channel == bitlbee_channel: + elif channel == w.config_get_plugin("channel"): nick_completer = w.config_string("weechat.completion.nick_completer") parts = input_s.split(":", 1) if len(parts) > 1: nick = parts[0] send_typing(nick, 1) - return w.WEECHAT_RC_OK def typing_disable_timer(data, remaining_calls): nick, cookie = data.rsplit(":", 1) cookie = int(cookie) - if sending_typing[nick] == cookie: + if nick in sending_typing and sending_typing[nick]==cookie: send_typing_ctcp(nick, 0) - sending_typing[nick] = False + del sending_typing[nick] return w.WEECHAT_RC_OK + def send_typing_ctcp(nick, level): - buffer = w.buffer_search("irc", "%s.%s" % (bitlbee_server_name, bitlbee_channel)) + if not channel_has_nick(w.config_get_plugin("server"), + w.config_get_plugin("channel"), nick): + return + buffer = w.buffer_search("irc", "%s.%s" % + (w.config_get_plugin("server"), + w.config_get_plugin("channel")) ) w.command(buffer, "/mute -all /ctcp %s TYPING %i" % (nick, level)) + def send_typing(nick, level): - if not channel_has_nick(bitlbee_server_name, bitlbee_channel, nick): - return - cookie = sending_typing.get(nick, 1) + 1 - if not sending_typing.get(nick, None): - send_typing_ctcp(nick, level) - sending_typing[nick] = cookie - w.hook_timer(4000, 0, 1, "typing_disable_timer", "%s:%i" % (nick, cookie)) + if level == 0 and nick in sending_typing: + send_typing_ctcp(nick, 0) + del sending_typing[nick] + elif level > 0 : + if nick not in sending_typing: + send_typing_ctcp(nick, level) + cookie = sending_typing.get(nick, 0) + 1 + sending_typing[nick] = cookie + w.hook_timer( int(1000 * float(w.config_get_plugin('timeout'))), 0, 1, + "typing_disable_timer", "%s:%i" % (nick, cookie)) def typing_notice_item_cb(data, buffer, args): @@ -147,11 +170,20 @@ return "" -if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, +# Main +if __name__ == "__main__": + if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "", ""): - w.hook_signal("input_text_changed", "typed_char", "") - w.hook_signal(bitlbee_server_name + ",irc_in_quit", "stop_typing", "") - w.hook_signal(bitlbee_server_name + ",irc_in_privmsg", "stop_typing", "") - w.bar_item_new('bitlbee_typing_notice', 'typing_notice_item_cb', '') - w.hook_modifier("irc_in_privmsg", "ctcp_cb", "") + if not w.config_get_plugin('channel'): + w.config_set_plugin('channel', "&bitlbee") + if not w.config_get_plugin('server'): + w.config_set_plugin('server', "localhost") + if not w.config_get_plugin('timeout'): + w.config_set_plugin('timeout', "4") + + w.hook_signal("input_text_changed", "typed_char", "") + w.hook_signal(w.config_get_plugin("server")+",irc_in_quit", "stop_typing", "") + w.hook_signal(w.config_get_plugin("server")+",irc_in_privmsg", "stop_typing", "") + w.bar_item_new('bitlbee_typing_notice', 'typing_notice_item_cb', '') + w.hook_modifier("irc_in_privmsg", "ctcp_cb", "") diff -Nru weechat-scripts-20130123/python/bufsize.py weechat-scripts-20131007/python/bufsize.py --- weechat-scripts-20130123/python/bufsize.py 2013-01-23 19:00:16.000000000 +0000 +++ weechat-scripts-20131007/python/bufsize.py 2013-10-07 12:14:48.000000000 +0000 @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2012 by nils_2 -# and nesthib +# Copyright (c) 2012-2013 by nils_2 +# and nesthib # # scroll indicator; displaying number of lines below last line, overall lines in buffer, number of current line and percent displayed # @@ -18,6 +18,9 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-01-25: nils_2 (freenode.#weechat) +# 0.3 : make script compatible with Python 3.x +# : internal changes # 2012-07-09: nils_2 (freenode.#weechat) # 0.2 : fix: display bug with more than one window # : hide item when buffer empty @@ -30,16 +33,16 @@ # https://github.com/weechatter/weechat-scripts try: - import weechat,re + import weechat, re except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = "bufsize" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.2" +SCRIPT_VERSION = "0.3" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "scroll indicator; displaying number of lines below last line, overall lines in buffer, number of current line and percent displayed" @@ -48,7 +51,8 @@ } # ================================[ weechat item ]=============================== # regexp to match ${color} tags -regex_color=re.compile('\$\{[^\{\}]+\}') +regex_color=re.compile('\$\{([^\{\}]+)\}') + # regexp to match ${optional string} tags regex_optional_tags=re.compile('%\{[^\{\}]+\}') @@ -71,14 +75,11 @@ '%L': str(lines_count), '%P': str(percent)+"%"} - bufsize_item = OPTIONS['format'] - - # substitute colors in output - for color_tag in regex_color.findall(bufsize_item): - bufsize_item = bufsize_item.replace(color_tag, weechat.color(color_tag.lstrip('${').rstrip('}'))) + bufsize_item = substitute_colors(OPTIONS['format']) # replace mandatory tags - for tag in tags.keys(): + for tag in list(tags.keys()): +# for tag in tags.keys(): bufsize_item = bufsize_item.replace(tag, tags[tag]) # replace optional tags @@ -91,6 +92,9 @@ return bufsize_item +def substitute_colors(text): + # substitute colors in output + return re.sub(regex_color, lambda match: weechat.color(match.group(1)), text) def count_lines(winpointer,bufpointer): @@ -120,7 +124,7 @@ # ================================[ weechat options and description ]=============================== def init_options(): - for option,value in OPTIONS.items(): + for option,value in list(OPTIONS.items()): if not weechat.config_get_plugin(option): weechat.config_set_plugin(option, value[0]) else: diff -Nru weechat-scripts-20130123/python/chanact.py weechat-scripts-20131007/python/chanact.py --- weechat-scripts-20130123/python/chanact.py 2013-01-23 19:00:07.000000000 +0000 +++ weechat-scripts-20131007/python/chanact.py 2013-10-07 12:14:40.000000000 +0000 @@ -4,6 +4,10 @@ # (this script requires WeeChat 0.3.0 or newer) # # History: +# 2013-09-16, d33tah +# version 0.8: Added sort_by_number configuration variable. +# 2013-03-18, mythmon +# version 0.7: Channels get a bonus based on priority in sorting. # 2012-02-09, mythmon # version 0.6: Allow sorting of channels # 2010-10-21, xt @@ -59,7 +63,7 @@ SCRIPT_NAME = "chanact" SCRIPT_AUTHOR = "xt " -SCRIPT_VERSION = "0.6" +SCRIPT_VERSION = "0.8" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Hotlist replacement, use names and keybindings instead of numbers" @@ -77,6 +81,7 @@ 'use_keybindings' : 'on', 'delimiter' : ',', 'skip_number_binds' : 'on', + 'sort_by_number' : 'off', } hooks = ( @@ -92,7 +97,7 @@ args = args.split(' ') if args[0] == 'sort': if len(args) == 1: - s = sort_rank(buffer) + s = sort_rank(buffer, 0) w.prnt(buffer, 'Sort rank of this buffer: %d' % s) elif len(args) == 2: s = args[1] @@ -102,12 +107,14 @@ return w.WEECHAT_RC_OK -def sort_rank(b): - r = w.buffer_get_string(b, 'localvar_sort') - if r: - return int(r) +def sort_rank(buffer, priority): + rank = w.buffer_get_string(buffer, 'localvar_sort') + priority = int(priority) if priority else 0 + + if rank: + return int(rank) + priority else: - return 0 + return priority def keydict_update(*args): @@ -151,7 +158,8 @@ if priority < int(w.config_get_plugin('lowest_priority')): continue - number = str(w.infolist_integer(hotlist, 'buffer_number')) + int_number = w.infolist_integer(hotlist, 'buffer_number') + number = str(int_number) thebuffer = w.infolist_pointer(hotlist, 'buffer_pointer') name = w.buffer_get_string(thebuffer, 'short_name') @@ -179,9 +187,12 @@ number, w.color(reset)) - activity.append((entry, thebuffer)) + activity.append((entry, thebuffer, sort_rank(thebuffer, priority), int_number)) - activity.sort(key=lambda t: sort_rank(t[1]), reverse=True) + if w.config_get_plugin('sort_by_number') == "on": + activity.sort(key=lambda t: int(t[3])) + else: + activity.sort(key=lambda t: int(t[2]), reverse=True) w.infolist_free(hotlist) if activity: diff -Nru weechat-scripts-20130123/python/chanop.py weechat-scripts-20131007/python/chanop.py --- weechat-scripts-20130123/python/chanop.py 2013-01-23 19:00:09.000000000 +0000 +++ weechat-scripts-20131007/python/chanop.py 2013-10-07 12:14:42.000000000 +0000 @@ -76,10 +76,6 @@ # "/msg q op $channel $nick" # (for quakenet only) # -# * plugins.var.python.chanop.deop_command: -# Same as op_command but for deop. -# It accepts the special vars $server, $channel and $nick -# # * plugins.var.python.chanop.autodeop: # Enables auto-deop'ing after using any of the ban or kick commands. # Note that if you got op manually (like with /oop) then the script won't @@ -113,6 +109,9 @@ # it only in networks that support it, like freenode. # Valid values: 'on', 'off' Default: 'off' # +# Example: +# /set plugins.var.python.chanop.enable_remove.freenode on +# # * plugins.var.python.chanop.display_affected: # Whenever a new ban is set, chanop will show the users affected by it. # This is intended for help operators to see if their ban is too wide or @@ -130,6 +129,12 @@ # This also applies to /obankick command, multiple bankicks would be enabled. # Valid values: 'on', 'off' Default: 'off' # +# * plugins.var.python.chanop.enable_bar: +# This will enable a pop-up bar for displaying chanop messages that would +# otherwise be printed in the buffer. This bar also shows in realtime the +# users affected by a ban you're about to set. +# Valid values: 'on', 'off' Default: 'on' +# # # The following configs are defined per server and are updated by the script only. # @@ -149,7 +154,7 @@ # Examples: # apply exemptions with mask autocompletion # /alias -completion %(chanop_ban_mask) exemption /mode $channel +e -# if you use grep.py script, grep with host autocompletion, for look clones. +# if you use grep.py script, grep with host autocompletion, for look clones. # /alias -completion %(chanop_hosts) ogrep /grep # # * chanop_unban_mask (used in /ounban) @@ -173,12 +178,12 @@ # Same as chanop_nicks, but with the usename part of the hostmask. # # * chanop_hosts (not used by chanop) -# Same as chanop_nicks, but with the host part of the hostmask. +# Same as chanop_nicks, but with the host part of the hostmask (includes previously used +# hostnames). # # # TODO -# * use dedicated config file like in urlgrab.py -# (win free config value validation by WeeChat) +# * use dedicated config file like in urlgrab.py? # * ban expire time # * save ban.mask and ban.hostmask across reloads # * allow to override quiet command (for quiet with ChanServ) @@ -189,6 +194,19 @@ # # # History: +# 2013-05-24 +# version 0.3.1: bug fixes +# * fix exceptions while fetching bans with /mode +# * fix crash with /olist command in networks that don't support +q channel masks. +# +# 2013-04-14 +# version 0.3: +# * cycle between different banmasks in /oban /oquiet commands. +# * added pop-up bar for show information. +# * save ban mask information (date and operator) +# * remove workarounds for < 0.3.2 weechat versions +# * python 3.0 compatibility (not tested) +# # 2013-01-02 # version 0.2.7: bug fixes: # * fix /obankick, don't deop before kicking. @@ -210,7 +228,7 @@ # # 2011-01-09 # version 0.2.3: bug fixes. -# +# # 2010-12-23 # version 0.2.2: bug fixes. # @@ -258,13 +276,15 @@ # version 0.1: Initial release ### +WEECHAT_VERSION = (0x30200, '0.3.2') + SCRIPT_NAME = "chanop" SCRIPT_AUTHOR = "Elián Hanisch " -SCRIPT_VERSION = "0.2.7" +SCRIPT_VERSION = "0.3.1" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Helper script for IRC Channel Operators" -### default settings ### +# default settings settings = { 'op_command' :'/msg chanserv op $channel $nick', 'autodeop' :'on', @@ -274,31 +294,37 @@ 'kick_reason' :'', 'enable_multi_kick' :'off', 'display_affected' :'on', +'enable_bar' :'on', } - try: import weechat from weechat import WEECHAT_RC_OK, prnt import_ok = True except ImportError: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") import_ok = False -import getopt, re, string -from time import time +import os +import re +import time +import string +import getopt +from collections import defaultdict +from shelve import DbfilenameShelf as Shelf chars = string.maketrans('', '') -################ -### Messages ### +# ----------------------------------------------------------------------------- +# 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'): + prnt(buffer, '%s%s %s' % (weechat.prefix('error'), script_nick, s)) + value = weechat.config_get_plugin('debug') + if value and boolDict[value]: import traceback if traceback.sys.exc_type: trace = traceback.format_exc() @@ -308,12 +334,17 @@ """normal msg""" prnt(buffer, '%s\t%s' %(script_nick, s)) -############## -### Config ### +def _no_debug(*args): + pass + +debug = _no_debug + +# ----------------------------------------------------------------------------- +# Config # TODO Need to refactor all this too -boolDict = {'on':True, 'off':False} +boolDict = {'on':True, 'off':False, True:'on', False:'off'} def get_config_boolean(config, get_function=None, **kwargs): if get_function and callable(get_function): value = get_function(config, **kwargs) @@ -376,11 +407,10 @@ value = weechat.config_get_plugin(config) return value +# ----------------------------------------------------------------------------- +# Utils -############# -### Utils ### - -now = lambda: int(time()) +now = lambda: int(time.time()) def time_elapsed(elapsed, ret=None, level=2): time_hour = 3600 @@ -415,9 +445,8 @@ ret = time_elapsed(elapsed, ret, level) return ret - -################# -### IRC utils ### +# ----------------------------------------------------------------------------- +# IRC utils _hostmaskRe = re.compile(r':?\S+!\S+@\S+') # poor but good enough def is_hostmask(s): @@ -498,7 +527,7 @@ def get_user(s, trim=False): """'nick!user@host' => 'user'""" - assert is_hostmask(s) + assert is_hostmask(s), "Invalid hostmask: %s" % s s = s[s.find('!') + 1:s.find('@')] if trim: # remove the stuff not part of the username. @@ -510,7 +539,7 @@ def get_host(s): """'nick!user@host' => 'host'""" - assert is_hostmask(s) + assert is_hostmask(s), "Invalid hostmask: %s" % s if ' ' in s: return s[s.find('@') + 1:s.find(' ')] return s[s.find('@') + 1:] @@ -521,12 +550,6 @@ def is_nick(s): return weechat.info_get('irc_is_nick', s) -# for old WeeChat -_nickchars = re.escape(r'[]\`_^{|}') -_nickRe = re.compile(r'^[A-Za-z%s][-0-9A-Za-z%s]*$' %(_nickchars, _nickchars)) -def _is_nick(s): - return bool(_nickRe.match(s)) - def irc_buffer(buffer): """Returns pair (server, channel) or None if buffer isn't an irc channel""" get_string = weechat.buffer_get_string @@ -536,9 +559,8 @@ server = get_string(buffer, 'localvar_server') return (server, channel) - -####################### -### WeeChat classes ### +# ----------------------------------------------------------------------------- +# WeeChat classes class InvalidIRCBuffer(Exception): pass @@ -547,7 +569,7 @@ def function(*args, **kwargs): try: return f(*args, **kwargs) - except Exception, e: + except Exception as e: error(e) return function @@ -577,6 +599,14 @@ setattr(__main__, name, method) return name +def weechat_command(buffer, cmd): + """I want to always keep debug() calls for this""" + if buffer: + debug("%ssending: %r buffer: %s", COLOR_WHITE, cmd, buffer) + else: + debug("%ssending: %r", COLOR_WHITE, cmd) + weechat.command(buffer, cmd) + class Infolist(object): """Class for reading WeeChat's infolists.""" @@ -588,14 +618,15 @@ 'flags' :'integer', 'prefixes' :'string', 'is_connected':'integer', + 'buffer' :'pointer', } _use_flags = False - def __init__(self, name, args=''): + def __init__(self, name, args='', pointer=''): self.cursor = 0 #debug('Generating infolist %r %r', name, args) - self.pointer = weechat.infolist_get(name, '', args) + self.pointer = weechat.infolist_get(name, pointer, args) if self.pointer == '': raise Exception("Infolist initialising failed (name:'%s' args:'%s')" %(name, args)) @@ -649,25 +680,21 @@ def free(self): if self.pointer: - #debug('Freeing Infolist') weechat.infolist_free(self.pointer) self.pointer = '' - def nick_infolist(server, channel): try: return Infolist('irc_nick', '%s,%s' % (server, channel)) except: raise InvalidIRCBuffer('%s.%s' % (server, channel)) - class NoArguments(Exception): pass class ArgumentError(Exception): pass - class Command(object): """Class for hook WeeChat commands.""" description, usage, help = "WeeChat command.", "[define usage template]", "detailed help here" @@ -677,8 +704,8 @@ def __init__(self): assert self.command, "No command defined" self.__name__ = self.command - self._pointer = '' - self._callback = '' + self._pointer = '' + self._callback = '' def __call__(self, *args): return self.callback(*args) @@ -686,9 +713,14 @@ def callback(self, data, buffer, args): """Called by WeeChat when /command is used.""" self.data, self.buffer, self.args = data, buffer, args + debug("%s[%s] data: \"%s\" buffer: \"%s\" args: \"%s\"", COLOR_DARKGRAY, + self.command, + data, + buffer, + args) try: self.parser(args) # argument parsing - except ArgumentError, e: + except ArgumentError as e: error('Argument error, %s' %e) except NoArguments: pass @@ -715,7 +747,7 @@ self.completion, self._callback, '') if pointer == '': - raise Exception, "hook_command failed: %s %s" %(SCRIPT_NAME, self.command) + raise Exception("hook_command failed: %s %s" % (SCRIPT_NAME, self.command)) self._pointer = pointer def unhook(self): @@ -724,9 +756,72 @@ self._pointer = '' self._callback = '' +class Bar(object): + def __init__(self, name, hidden=False, items=''): + self.name = name + self.hidden = hidden + self._pointer = '' + self._items = items + + def new(self): + assert not self._pointer, "Bar %s already created" % self.name + pointer = weechat.bar_search(self.name) + if not pointer: + pointer = weechat.bar_new(self.name, boolDict[self.hidden], '0', 'window', + 'active', 'bottom', 'horizontal', 'vertical', + '0', '1', 'default', 'cyan', 'blue', 'off', + self._items) + if not pointer: + raise Exception("bar_new failed: %s %s" % (SCRIPT_NAME, self.name)) + + self._pointer = pointer + + def getPointer(self): + return weechat.bar_search(self.name) + + def show(self): + pointer = self.getPointer() + if pointer and self.hidden: + weechat.bar_set(pointer, 'hidden', 'off') + self.hidden = False + return pointer + + def hide(self): + pointer = self.getPointer() + if pointer and not self.hidden: + weechat.bar_set(pointer, 'hidden', 'on') + self.hidden = True + + def remove(self): + pointer = self.getPointer() + if pointer: + weechat.bar_remove(pointer) + self._pointer = '' + + def __len__(self): + """True False evaluation.""" + if self.getPointer(): + return 1 + else: + return 0 + +class PopupBar(Bar): + _timer_hook = '' + popup_mode = False + + def popup(self, delay=10): + if self.show(): + if self._timer_hook: + weechat.unhook(self._timer_hook) + self._timer_hook = weechat.hook_timer(delay * 1000, 0, 1, callback(self._timer), '') + + def _timer(self, data, counter): + self.hide() + self._timer_hook = '' + return WEECHAT_RC_OK -############################ -### Per buffer variables ### +# ----------------------------------------------------------------------------- +# Per buffer variables class BufferVariables(dict): """Keeps variables and objects of a specific buffer.""" @@ -743,10 +838,9 @@ return self[k] def __setattr__(self, k, v): - debug('Buffer[%s] %s ... %s => %s', self.buffer, k, self.get(k), v) + debug(' -- buffer[%s] %s ... %s => %s', self.buffer, k, self.get(k), v) self[k] = v - class ChanopBuffers(object): """Keeps track of BuffersVariables instances in chanop.""" buffer = '' @@ -791,9 +885,8 @@ def get_config_int(self, config): return get_config_int(config, self.get_config) - -########################## -### IRC messages queue ### +# ----------------------------------------------------------------------------- +# IRC messages queue class Message(ChanopBuffers): command = None @@ -823,14 +916,11 @@ self.send(cmd) def send(self, cmd): - if weechat.config_get_plugin('debug'): - debug('sending: %r', cmd) - weechat.command(self.buffer, cmd) + weechat_command(self.buffer, cmd) def __repr__(self): return '' %(self.command, self.args) - class IrcCommands(ChanopBuffers): """Class that manages and sends the script's commands to WeeChat.""" @@ -849,7 +939,7 @@ data = 'MODE %s +o %s' % (vars.channel, vars.nick) signal = signal_data.split(None, 1)[1] if signal == data: - #debug('We got op') + debug('GOT OP') # add this channel to our watchlist config = 'watchlist.%s' % vars.server channels = CaseInsensibleSet(get_config_list(config)) @@ -895,7 +985,7 @@ nick, host = string.rsplit(None, 1)[1].split('=') nick, host = nick.strip(':*'), host[1:] hostmask = '%s!%s' % (nick, host) - #debug('USERHOST: %s %s', nick, hostmask) + debug('USERHOST: %s %s', nick, hostmask) userCache.remember(modifier_data, nick, hostmask) weechat.unhook(vars.msgHook) weechat.unhook(vars.msgTimeout) @@ -974,9 +1064,9 @@ value = self.replace_vars(self.get_config('op_command')) if not value: - raise Exception, "No command defined for get op." + raise Exception("No command defined for get op.") msg = self.OpMessage(value) - self.queue(msg) + self.queue(msg, insert=True) def Deop(self): msg = self.DeopMessage('-o', self.nick) @@ -1048,9 +1138,8 @@ def __repr__(self): return '' % ', '.join(map(repr, self.commands)) - -######################### -### User/Mask classes ### +# ----------------------------------------------------------------------------- +# User/Mask classes _rfc1459trans = string.maketrans(string.ascii_uppercase + r'\[]', string.ascii_lowercase + r'|{}') @@ -1060,14 +1149,13 @@ class CaseInsensibleString(str): def __init__(self, s=''): self.lowered = IRClower(s) - + lower = lambda self: self.lowered translate = lambda self, trans: self.lowered __eq__ = lambda self, s: self.lowered == IRClower(s) __ne__ = lambda self, s: not self == s __hash__ = lambda self: hash(self.lowered) - def caseInsensibleKey(k): if isinstance(k, str): return CaseInsensibleString(k) @@ -1075,12 +1163,11 @@ return tuple(map(caseInsensibleKey, k)) return k - class CaseInsensibleDict(dict): key = staticmethod(caseInsensibleKey) def __init__(self, **kwargs): - for k, v in kwargs.iteritems(): + for k, v in kwargs.items(): self[k] = v def __setitem__(self, k, v): @@ -1098,6 +1185,8 @@ def pop(self, k): return dict.pop(self, self.key(k)) +class CaseInsensibleDefaultDict(defaultdict, CaseInsensibleDict): + pass class CaseInsensibleSet(set): normalize = staticmethod(caseInsensibleKey) @@ -1118,7 +1207,6 @@ def remove(self, v): set.remove(self, self.normalize(v)) - class ChannelWatchlistSet(CaseInsensibleSet): _updated = False def __contains__(self, v): @@ -1142,7 +1230,6 @@ chanopChannels = ChannelWatchlistSet() - class ServerChannelDict(CaseInsensibleDict): def getChannels(self, server, item=None): """Return a list of channels that match server and has item if given""" @@ -1154,78 +1241,104 @@ def purge(self): for key in self.keys(): if key not in chanopChannels: - #debug('Removing %s.%s list, not in watchlist. (%s items)', key[0], key[1], len(self[key])) + debug('removing %s mask list, not in watchlist.', key) del self[key] - for data in self.itervalues(): + for data in self.values(): data.purge() -# Masks +# ----------------------------------------------------------------------------- +# Channel Modes (bans) + class MaskObject(object): - def __init__(self, mask, hostmask=None, operator=None, date=None):#, expires=None): + def __init__(self, mask, hostmask=[], operator='', date=0, expires=0): self.mask = mask - self.hostmask = hostmask self.operator = operator if date: date = int(date) else: date = now() self.date = date -# self.expires = expires + if isinstance(hostmask, str): + hostmask = [ hostmask ] + self.hostmask = hostmask + self.expires = int(expires) - def __repr__(self): - return "" %self.mask + def serialize(self): + data = ';'.join([ self.operator, + str(self.date), + str(self.expires), + ','.join(self.hostmask) ]) + return data + + def deserialize(self, data): + op, date, expires, hostmasks = data.split(';') + assert op and date, "Error reading chanmask option %s, missing operator or date" % self.mask + if not is_hostmask(op): + raise Exception('Error reading chanmask option %s, invalid usermask %r' \ + % (self.mask, op)) + self.operator = op + try: + self.date = int(date) + except ValueError: + self.date = int(time.mktime(time.strptime(date,'%Y-%m-%d %H:%M:%S'))) + if expires: + self.expires = int(expires) + else: + self.expires = 0 + if hostmasks: + hostmasks = hostmasks.split(',') + if not all(map(is_hostmask, hostmasks)): + raise Exception('Error reading chanmask option %s, a hostmask is invalid: %s' \ + % (self.mask, hostmasks)) + + self.hostmask = hostmasks + + def __repr__(self): + return "" % self.mask class MaskList(CaseInsensibleDict): + """Single list of masks""" def __init__(self, server, channel): - self.server = CaseInsensibleString(server) - self.channel = CaseInsensibleString(channel) self.synced = 0 def add(self, mask, **kwargs): if mask in self: # mask exists, update it ban = self[mask] - for attr, value in kwargs.iteritems(): - if value: + for attr, value in kwargs.items(): + if value and not getattr(ban, attr): setattr(ban, attr, value) else: - self[mask] = MaskObject(mask, **kwargs) - - def searchByHostmask(self, hostmask): - return [ mask for mask in self if hostmask_match(mask, hostmask) ] - - def searchByNick(self, nick): - try: - hostmask = userCache.getHostmask(nick, self.server, self.channel) - return self.searchByHostmask(hostmask) - except KeyError: - return [] + ban = self[mask] = MaskObject(mask, **kwargs) + return ban - def search(self, s): - if is_nick(s): - masks = self.searchByNick(s) - elif is_hostmask(s): - masks = self.searchByHostmask(s) +# def searchByNick(self, nick): +# try: +# hostmask = userCache.getHostmask(nick, self.server, self.channel) +# return self.searchByHostmask(hostmask) +# except KeyError: +# return [] + + def search(self, pattern, reverseMatch=False): + if reverseMatch: + L = [ mask for mask in self if hostmask_match(mask, pattern) ] else: - masks = pattern_match_list(s, self.iterkeys()) - return masks + L = pattern_match_list(pattern, self.keys()) + return L def purge(self): pass - class MaskCache(ServerChannelDict): - """Keeps a list of our bans for quick look up.""" - def __init__(self, mode='b'): - self.mode = mode - + """Keeps a cache of masks for different channels.""" def add(self, server, channel, mask, **kwargs): """Adds a ban to (server, channel) banlist.""" key = (server, channel) if key not in self: self[key] = MaskList(*key) - self[key].add(mask, **kwargs) + ban = self[key].add(mask, **kwargs) + return ban def remove(self, server, channel, mask=None):#, hostmask=None): key = (server, channel) @@ -1238,8 +1351,54 @@ except KeyError: pass +class ChanopCache(Shelf): + def __init__(self, filename): + path = os.path.join(weechat.info_get('weechat_dir', ''), filename) + Shelf.__init__(self, path, writeback=True) + +class ModeCache(ChanopCache): + """class for store channel modes lists.""" + def __init__(self, filename): + ChanopCache.__init__(self, filename) + self.modes = set() + self.map = CaseInsensibleDict() + + # reset all sync timers + for cache in self.values(): + for masklist in cache.values(): + masklist.synced = 0 + + def registerMode(self, mode, *args): + if mode not in self: + cache = MaskCache() + self[mode] = cache + + if mode not in self.modes: + self.modes.add(mode) + + self.map[mode] = mode + for name in args: + self.map[name] = mode + + def __getitem__(self, mode): + try: + return ChanopCache.__getitem__(self, mode) + except KeyError: + return ChanopCache.__getitem__(self, self.map[mode]) -class MaskHandler(ServerChannelDict): + def add(self, server, channel, mode, mask, **kwargs): + assert mode in self.modes + self[mode].add(server, channel, mask, **kwargs) + + def remove(self, server, channel, mode, mask): + self[mode].remove(server, channel, mask) + + def purge(self): + for cache in self.values(): + cache.purge() + +class MaskSync(object): + """Class for fetch and sync bans of any channel and mode.""" __name__ = '' _hide_msg = False @@ -1250,10 +1409,10 @@ _hook_quiet_mask = '' _hook_quiet_end = '' - caches = {} - _modeTranslation = CaseInsensibleDict() + # sync queue stuff queue = [] - _execute = CaseInsensibleDict() + _maskbuffer = CaseInsensibleDefaultDict(list) + _callback = CaseInsensibleDict() def hook(self): # 367 - ban mask @@ -1280,41 +1439,17 @@ weechat.unhook(attr) setattr(self, hook, '') - def __setitem__(self, key, value): - try: - self[key].append(value) - except: - ServerChannelDict.__setitem__(self, key, [value]) - - def addCache(self, mode, *args): - def fetch(server, channel, execute=None): - self.fetch(server, channel, mode, execute) - - # XXX monkey punching is BAD! - cache = MaskCache(mode) - cache.fetch = fetch - - self.caches[mode] = cache - for name in args: - self._modeTranslation[name] = cache - - def getCache(self, mode): - try: - return self.caches[mode] - except KeyError: - return self._modeTranslation[mode] - - def fetch(self, server, channel, mode, execute=None): + def fetch(self, server, channel, mode, callback=None): """Fetches masks for a given server and channel.""" buffer = weechat.buffer_search('irc', 'server.%s' %server) if not buffer or not weechat.info_get('irc_is_channel', channel): # invalid server or channel - return + return # check modes if mode not in supported_modes(server): return - maskCache = self.caches[mode] + maskCache = modeCache[mode] key = (server, channel) # check the last time we did this try: @@ -1324,15 +1459,15 @@ return except KeyError: pass - + if not self.queue: self.queue.append((server, channel, mode)) self._fetch(server, channel, mode) elif (server, channel, mode) not in self.queue: self.queue.append((server, channel, mode)) - if execute: - self._execute[server, channel] = execute + if callback: + self._callback[server, channel] = callback def _fetch(self, server, channel, mode): buffer = weechat.buffer_search('irc', 'server.%s' %server) @@ -1340,92 +1475,86 @@ return cmd = '/mode %s %s' %(channel, mode) self._hide_msg = True - weechat.command(buffer, cmd) + weechat_command(buffer, cmd) def _maskCallback(self, data, modifier, modifier_data, string): - """callback for store a single mask. - - irc_in_367 => ban - irc_in_728 => quiet - """ - + """callback for store a single mask.""" + #debug("MASK %s: %s %s", modifier, modifier_data, string) args = string.split() + if self.queue: + server, channel, _ = self.queue[0] + else: + server, channel = modifier_data, args[3] + if modifier == 'irc_in_367': - mode = 'b' - if len(args) < 7: - channel, mask = args[3], args[4] + try: + mask, op, date = args[4:] + except IndexError: + mask = args[4] op = date = None - else: - channel, mask, op, date = args[3:] elif modifier == 'irc_in_728': - channel, mode, mask, op, date = args[3:] + mask, op, date = args[5:] - debug("MASK %s: %s %s %s %s", modifier, channel, mask, op, date) # store temporally until "end list" msg - self[modifier_data, channel] = (mask, op, date) + self._maskbuffer[server, channel].append((mask, op, date)) if self._hide_msg: - return '' - else: - return string + string = '' + return string def _endCallback(self, data, modifier, modifier_data, string): - """callback for end of channel's mask list. - - irc_in_368 => ban - irc_in_729 => quiet - """ - - L = string.split() - if modifier == 'irc_in_368': - channel, mode = L[3], L[7] - elif modifier == 'irc_in_729': - channel, mode = L[3], L[4] - server = modifier_data - debug("MASK END %s: %s %s", modifier, channel, mode) - - try: - maskCache = self.getCache(mode) - for banmask, op, date in self[server, channel]: - maskCache.add(server, channel, banmask, operator=op, date=date) - masklist = maskCache[server, channel] - except KeyError: - masklist = maskCache[server, channel] = MaskList(server, channel) - finally: - if (server, channel) in self: - del self[server, channel] - - masklist.synced = now() + """callback for end of channel's mask list.""" + #debug("MASK END %s: %s %s", modifier, modifier_data, string) + if self.queue: + server, channel, mode = self.queue.pop(0) + else: + args = string.split() + server, channel = modifier_data, args[3] + if modifier == 'irc_in_368': + mode = args[7] + elif modifier == 'irc_in_729': + mode = args[4] + else: + return string - # run finishing functions if any - if (server, channel) in self._execute: - self._execute[server, channel]() - del self._execute[server, channel] + maskCache = modeCache[mode] + # delete old masks in cache + if (server, channel) in maskCache: + masklist = maskCache[server, channel] + banmasks = [ L[0] for L in self._maskbuffer[server, channel] ] + for mask in masklist.keys(): + if mask not in banmasks: + del masklist[mask] + + for banmask, op, date in self._maskbuffer[server, channel]: + maskCache.add(server, channel, banmask, operator=op, date=date) + del self._maskbuffer[server, channel] try: - if self._hide_msg: - return '' - else: - return string - finally: - if self.queue: - del self.queue[0] - if self.queue: - next = self.queue[0] - self._fetch(*next) - else: - self._hide_msg = False + maskList = maskCache[server, channel] + except KeyError: + maskList = maskCache[server, channel] = MaskList(server, channel) + maskList.synced = now() - def purge(self): - for maskCache in self.caches.itervalues(): - maskCache.purge() + # run hooked functions if any + if (server, channel) in self._callback: + self._callback[server, channel]() + del self._callback[server, channel] + if self._hide_msg: + string = '' + if self.queue: + next = self.queue[0] + self._fetch(*next) + else: + assert not self._maskbuffer, "mask buffer not empty: %s" % self._maskbuffer.keys() + self._hide_msg = False + return string -maskHandler = MaskHandler() -maskHandler.addCache('b', 'ban', 'bans') -maskHandler.addCache('q', 'quiet', 'quiets') +maskSync = MaskSync() +# ----------------------------------------------------------------------------- +# User cache -# Users class UserObject(object): def __init__(self, nick, hostmask=None): self.nick = nick @@ -1456,7 +1585,6 @@ def __repr__(self): return '' %(self.hostmask or self.nick) - class ServerUserList(CaseInsensibleDict): def __init__(self, server): self.server = server @@ -1473,10 +1601,9 @@ n = now() for nick, user in self.items(): if user._channels < 1 and (n - user.seen) > self._purge_time: - #debug('purging user: %s' %user) + #debug('purging old user: %s' % nick) del self[nick] - class UserList(ServerUserList): def __init__(self, server, channel): self.server = server @@ -1485,31 +1612,32 @@ self._purge_time = 3600*2 # 2 hours def __setitem__(self, nick, user): + #debug('%s %s: join, %s', self.server, self.channel, nick) if nick not in self: user._channels += 1 if nick in self._purge_list: + #debug(' - removed from purge list') del self._purge_list[nick] ServerUserList.__setitem__(self, nick, user) def part(self, nick): try: + #debug('%s %s: part, %s', self.server, self.channel, nick) user = self[nick] self._purge_list[nick] = user except KeyError: pass def values(self): - if not all(self.itervalues()): + if not all(ServerUserList.values(self)): userCache.who(self.server, self.channel) - L = list(self.itervalues()) - L.sort(key=lambda x:x.seen) - return reversed(L) - + return sorted(ServerUserList.values(self), key=lambda x:x.seen, reverse=True) + def hostmasks(self, sorted=False, all=False): if sorted: users = self.values() else: - users = self.itervalues() + users = ServerUserList.values(self) if all: # return all known hostmasks return [ hostmask for user in users for hostmask in user._hostmask ] @@ -1520,7 +1648,7 @@ def nicks(self, *args, **kwargs): # if not all(self.itervalues()): # userCache.who(self.server, self.channel) - L = list(self.iteritems()) + L = list(self.items()) L.sort(key=lambda x:x[1].seen) return reversed([x[0] for x in L]) @@ -1536,6 +1664,7 @@ n = now() for nick, user in self._purge_list.items(): if (n - user.seen) > self._purge_time: + #debug('%s %s: forgeting about %s', self.server, self.channel, nick) user._channels -= 1 try: del self._purge_list[nick] @@ -1543,7 +1672,6 @@ except KeyError: pass - class UserCache(ServerChannelDict): __name__ = '' servercache = CaseInsensibleDict() @@ -1551,7 +1679,7 @@ _channels = CaseInsensibleSet() def generateCache(self, server, channel): - #debug('generateCache: %s %s', server, channel) + debug('* building cache: %s %s', server, channel) users = UserList(server, channel) try: infolist = nick_infolist(server, channel) @@ -1570,6 +1698,7 @@ user = self.remember(server, nick, hostmask) users[nick] = user self[server, channel] = users + debug("new cache of %s users", len(users)) return users def remember(self, server, nick, hostmask): @@ -1579,6 +1708,7 @@ if hostmask: user.update(hostmask) except KeyError: + #debug("%s: new user %s %s", server, nick, hostmask) user = UserObject(nick, hostmask) cache[nick] = user return user @@ -1599,7 +1729,8 @@ def __delitem__(self, k): # when we delete a channel, we need to reduce user._channels count # so they can be purged later. - for user in self[k].itervalues(): + #debug('forgeting about %s', k) + for user in self[k].values(): user._channels -= 1 ServerChannelDict.__delitem__(self, k) @@ -1617,16 +1748,15 @@ return self._channels.add((server, channel)) - + key = ('%s.%s' %(server, channel)).lower() self._hook_who = weechat.hook_modifier( 'irc_in_352', callback(self._whoCallback), key) self._hook_who_end = weechat.hook_modifier( 'irc_in_315', callback(self._endWhoCallback), key) - #debug('WHO: %s', channel) buffer = weechat.buffer_search('irc', 'server.%s' %server) - weechat.command(buffer, '/WHO %s' %channel) + weechat_command(buffer, '/who %s' % channel) def _whoCallback(self, data, modifier, modifier_data, string): #debug('%s %s %s', modifier, modifier_data, string) @@ -1638,7 +1768,7 @@ nick, user, host = args[7], args[4], args[5] hostmask = '%s!%s@%s' %(nick, user, host) - #debug('WHO: %s', hostmask) + debug('WHO: %s', hostmask) self.remember(server, nick, hostmask) return '' @@ -1649,7 +1779,7 @@ if key != data: return string - #debug('end WHO') + debug('WHO: end.') weechat.unhook(self._hook_who) weechat.unhook(self._hook_who_end) self._hook_who = self._hook_who_end = None @@ -1657,7 +1787,7 @@ def purge(self): ServerChannelDict.purge(self) - for cache in self.servercache.itervalues(): + for cache in self.servercache.values(): cache.purge() userCache = UserCache() @@ -1672,7 +1802,7 @@ def parser(self, args): if not args: - weechat.command('', '/help %s' %self.command) + weechat_command('', '/help %s' % self.command) raise NoArguments self.setup(self.buffer) @@ -1680,11 +1810,10 @@ self.users = userCache[self.server, self.channel] try: self.execute_chanop() # call our command and queue messages for WeeChat - except InvalidIRCBuffer, e: + self.irc.run() # run queued messages + except InvalidIRCBuffer as e: error('Not in a IRC channel (%s)' % e) self.irc.clear() - else: - self.irc.run() # run queued messages self.infolist = None # free irc_nick infolist def execute_chanop(self): @@ -1732,19 +1861,31 @@ for nick in nicks: self.irc.Mode(mode, nick) - class CommandWithOp(CommandChanop): """Base class for all the commands that requires op status for work.""" + _enable_deopNow = True deop_delay = 0 + def __init__(self, *args, **kwargs): + CommandChanop.__init__(self, *args, **kwargs) + # update help so it adds --deop option + if self._enable_deopNow: + if self.usage: + self.usage += " " + if self.help: + self.help += "\n" + self.usage += "[--deop]" + self.help += " -o --deop: Forces deop immediately, without configured delay"\ + " (option must be the last argument)." + def setup(self, buffer): self.deopNow = False CommandChanop.setup(self, buffer) - + def parser(self, args): CommandChanop.parser(self, args) args = args.split() - if args[-1] in ('-o', '--deop'): + if self._enable_deopNow and args[-1] in ('-o', '--deop'): self.deopNow = True del args[-1] self.args = ' '.join(args) @@ -1752,9 +1893,13 @@ raise NoArguments def execute_chanop(self, *args): - self.irc.Op() self.execute_op(*args) + if not self.irc.commands: + # nothing in queue, no reason to op. + return + + self.irc.Op() if (self.autodeop and self.get_config_boolean('autodeop')) or self.deopNow: if self.deopNow: delay = self.deop_delay @@ -1787,7 +1932,6 @@ vars.deopHook = None return WEECHAT_RC_OK - # Chanop commands class Op(CommandChanop): description, usage = "Request operator privileges or give it to users.", "[nick [nick ... ]]", @@ -1818,14 +1962,14 @@ if self.inChannel(nick) and not self.has_op(nick): self.set_mode(nick) - class Deop(Op, CommandWithOp): description, usage, help = \ "Removes operator privileges from yourself or users.", "[nick [nick ... ]]", "" command = 'odeop' completion = '%(nicks)' - + prefix = '-' + _enable_deopNow = False def execute_chanop(self): if self.args: @@ -1843,9 +1987,8 @@ def execute_op(self, nicks): self.set_mode(*nicks) - class Kick(CommandWithOp): - description, usage = "Kick nick.", " [] [-o]" + description, usage = "Kick nick.", " []" help = \ "On freenode, you can set this command to use /remove instead of /kick, users"\ " will see it as if the user parted and it can bypass autojoin-on-kick scripts."\ @@ -1861,9 +2004,9 @@ say("Nick not in %s (%s)" % (self.channel, nick), self.buffer) self.irc.clear() - class MultiKick(Kick): - description, usage = "Kick one or more nicks.", " [ ... ] [:] [] [-o]" + description = "Kick one or more nicks." + usage = " [ ... ] [:] []" help = Kick.help + "\n\n"\ "Note: Is not needed, but use ':' as a separator between nicks and "\ "the reason. Otherwise, if there's a nick in the channel matching the "\ @@ -1897,31 +2040,43 @@ else: self.irc.clear() +ban_help = \ +"Mask options:\n"\ +" -h --host: Match hostname (*!*@host)\n"\ +" -n --nick: Match nick (nick!*@*)\n"\ +" -u --user: Match username (*!user@*)\n"\ +" -e --exact: Use exact hostmask.\n"\ +"\n"\ +"If no mask options are supplied, configured defaults are used.\n"\ +"\n"\ +"Completer:\n"\ +"%(script)s will attempt to guess a complete banmask from current\n"\ +"users when using in an incomplete banmask. Using in a\n"\ +"complete banmask will generate variations of it. \n"\ +"\n"\ +"Examples:\n"\ +" /%(cmd)s somebody --user --host\n"\ +" will ban with *!user@hostname mask.\n"\ +" /%(cmd)s nick!*@\n"\ +" will autocomple with 'nick!*@host'.\n"\ +" /%(cmd)s nick!*@*\n"\ +" will cycle through different banmask variations for the same user.\n" class Ban(CommandWithOp): description = "Ban user or hostmask." usage = \ - " [ ... ] [ [--host] [--user] [--nick] | --exact ] [-o]" - help = \ - "Mask options:\n"\ - " -h --host: Match hostname (*!*@host)\n"\ - " -n --nick: Match nick (nick!*@*)\n"\ - " -u --user: Match username (*!user@*)\n"\ - " -e --exact: Use exact hostmask. Can't be combined with other options.\n"\ - "\n"\ - "If no mask options are supplied, configured defaults are used.\n"\ - " -o: Forces deop immediately (without configured delay).\n"\ - "\n"\ - "Example:\n"\ - "/oban somebody --user --host\n"\ - " will ban with *!user@hostname mask.\n" + " [ ... ] [ [--host] [--user] [--nick] | --exact ]" command = 'oban' + help = ban_help % {'script': SCRIPT_NAME, 'cmd': command} completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*' banmask = [] mode = 'b' prefix = '+' - maskCache = maskHandler.caches[mode] + + def __init__(self): + self.maskCache = modeCache[self.mode] + CommandWithOp.__init__(self) def parser(self, args): if not args: @@ -1934,8 +2089,8 @@ args = args.split() try: (opts, args) = getopt.gnu_getopt(args, 'hune', ('host', 'user', 'nick', 'exact')) - except getopt.GetoptError, e: - raise ArgumentError, e + except getopt.GetoptError as e: + raise ArgumentError(e) self.banmask = [] for k, v in opts: if k in ('-h', '--host'): @@ -1976,7 +2131,7 @@ if is_ip(ip): host = '*%s' % ip s = '%s!%s@%s' %(nick, user, host) - assert is_hostmask(s), "Invalid banmask: %s" %s + assert is_hostmask(s), "Invalid hostmask: %s" % s return s if callable(hostmask): @@ -1987,13 +2142,17 @@ args = self.args.split() banmasks = [] for arg in args: - mask = arg - if not is_hostmask(arg): + if is_nick(arg): hostmask = self.getHostmask(arg) - if hostmask: - mask = self.make_banmask(hostmask) - if self.has_voice(arg): - self.irc.Devoice(arg) + if not hostmask: + say("Unknown nick (%s)" % arg, self.buffer) + continue + mask = self.make_banmask(hostmask) + if self.has_voice(arg): + self.irc.Devoice(arg) + else: + # probably an extban + mask = arg banmasks.append(mask) banmasks = set(banmasks) # remove duplicates self.ban(*banmasks) @@ -2012,14 +2171,12 @@ for mask in banmasks: self.irc.Mode(mode, mask, **kwargs) - class UnBan(Ban): - description, usage = "Remove bans.", " [ ... ] [-o]" + description, usage = "Remove bans.", " [ ... ]" command = 'ounban' help = \ "Autocompletion will use channel's bans, patterns allowed for autocomplete multiple"\ " bans.\n"\ - " -o: Forces deop immediately (without configured delay).\n"\ "\n"\ "Example:\n"\ "/%(cmd)s *192.168*\n"\ @@ -2027,44 +2184,45 @@ completion = '%(chanop_unban_mask)|%(chanop_nicks)|%*' prefix = '-' - def search_masks(self, hostmask): + def search_masks(self, hostmask, **kwargs): try: masklist = self.maskCache[self.server, self.channel] except KeyError: return [] - if callable(hostmask): + if callable(hostmask): def banmask(): - L = masklist.searchByHostmask(hostmask()) + L = masklist.search(hostmask(), **kwargs) if L: return L[0] return [ banmask ] - return masklist.searchByHostmask(hostmask) + return masklist.search(hostmask, **kwargs) def execute_op(self): args = self.args.split() banmasks = [] for arg in args: if is_hostmask(arg): - hostmask = arg + banmasks.extend(self.search_masks(arg)) elif is_nick(arg): hostmask = self.getHostmask(arg) + if hostmask: + banmasks.extend(self.search_masks(hostmask, reverseMatch=True)) + else: + # nick unknown to chanop + say("Unknown nick (%s)" % arg, self.buffer) else: banmasks.append(arg) - continue - banmasks.extend(self.search_masks(hostmask)) self.ban(*banmasks) - class Quiet(Ban): description = "Silence user or hostmask." - help = "This command is only for networks that support channel mode 'q'. See /help oban as well." command = 'oquiet' + help = "This command is only for networks that support channel mode 'q'.\n\n" \ + + ban_help % {'script': SCRIPT_NAME, 'cmd': command} completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*' mode = 'q' - maskCache = maskHandler.caches[mode] - class UnQuiet(UnBan): command = 'ounquiet' @@ -2073,8 +2231,6 @@ completion = '%(chanop_unquiet_mask)|%(chanop_nicks)|%*' mode = 'q' - maskCache = maskHandler.caches[mode] - class BanKick(Ban, Kick): description = "Bankicks nick." @@ -2092,19 +2248,16 @@ return hostmask = self.getHostmask(nick) - if hostmask: - banmask = self.make_banmask(hostmask) - self.ban(banmask) - else: - self.ban(nick) + # we already checked that nick is valid, so hostmask shouldn't be None + banmask = self.make_banmask(hostmask) + self.ban(banmask) if self.inChannel(nick): self.irc.Kick(nick, reason, wait=1) - class MultiBanKick(BanKick): description = "Bankicks one or more nicks." usage = \ - " [ ... ] [:] [] [ [--host)] [--user] [--nick] | --exact ] [-o]" + " [ ... ] [:] [] [ [--host)] [--user] [--nick] | --exact ]" completion = '%(chanop_nicks)|%*' def execute_op(self): @@ -2123,11 +2276,8 @@ for nick in nicks: hostmask = self.getHostmask(nick) - if hostmask: - banmask = self.make_banmask(hostmask) - self.ban(banmask) - else: - self.ban(nick) + banmask = self.make_banmask(hostmask) + self.ban(banmask) self.deop_delay = 1 for nick in nicks: @@ -2135,9 +2285,8 @@ self.deop_delay += 1 self.irc.Kick(nick, reason, wait=1) - class Topic(CommandWithOp): - description, usage = "Changes channel topic.", "[-delete | topic] [-o]" + description, usage = "Changes channel topic.", "[-delete | topic]" help = "Clear topic if '-delete' is the new topic." command = 'otopic' completion = '%(irc_channel_topic)||-delete' @@ -2145,10 +2294,8 @@ def execute_op(self): self.irc.queue(Message('/topic %s' %self.args)) - class Voice(CommandWithOp): - description, usage = "Gives voice to somebody.", "nick [nick ... ] [-o]" - help = " -o: Forces deop immediately (without configured delay)." + description, usage, help = "Gives voice to somebody.", "nick [nick ... ]", "" command = 'ovoice' completion = '%(nicks)|%*' @@ -2160,7 +2307,6 @@ if self.inChannel(nick) and not self.has_voice(nick): self.set_mode(nick) - class DeVoice(Voice): description = "Removes voice from somebody." command = 'odevoice' @@ -2170,10 +2316,8 @@ def has_voice(self, nick): return not Voice.has_voice(self, nick) - class Mode(CommandWithOp): - description, usage = "Changes channel modes.", " [-o]" - help = " -o: Forces deop immediately (without configured delay)." + description, usage, help = "Changes channel modes.", "", "" command = 'omode' def execute_op(self): @@ -2194,7 +2338,6 @@ for mode, arg in L: self.irc.Mode(mode, arg) - class ShowBans(CommandChanop): description, usage, help = "Lists bans or quiets of a channel.", "(bans|quiets) [channel]", "" command = 'olist' @@ -2212,17 +2355,18 @@ self.channel = channel type, _, args = args.partition(' ') if not type: - raise ValueError, 'missing argument' + raise ValueError('missing argument') try: - self.maskCache = maskHandler.getCache(type) - if type == 'b': - self.type = 'bans' - elif type == 'q': - self.type = 'quiets' - else: - self.type = type + mode = modeCache.map[type] except KeyError: - raise ValueError, 'incorrect argument' + raise ValueError('incorrect argument') + + self.mode = mode + # fix self.type so is "readable" (ie, 'bans' instead of 'b') + if mode == 'b': + self.type = 'bans' + elif mode == 'q': + self.type = 'quiets' args = args.strip() if args: self.channel = args @@ -2230,6 +2374,7 @@ def get_buffer(self): if self.showbuffer: return self.showbuffer + buffer = weechat.buffer_search('python', SCRIPT_NAME) if not buffer: buffer = weechat.buffer_new(SCRIPT_NAME, '', '', '', '') @@ -2254,9 +2399,8 @@ color_reset, self.formatTime(when))) if hostmask: - if not isinstance(hostmask, str): - hostmask = ' '.join(hostmask) - self.prnt(' %s%s' %(color_chat_host, hostmask)) + hostmasks = ' '.join(hostmask) + self.prnt(' %s%s' % (color_chat_host, hostmasks)) def clear(self): b = self.get_buffer() @@ -2274,25 +2418,29 @@ def execute(self): self.showbuffer = '' - if self.maskCache.mode not in supported_modes(self.server): + if self.mode not in supported_modes(self.server): self.clear() - self.prnt("\n%sNetwork '%s' doesn't support %s" %(color_channel, self.server, - self.type)) + self.prnt("\n%sNetwork '%s' doesn't support %s" % (color_channel, + self.server, + self.type)) return + + maskCache = modeCache[self.mode] key = (self.server, self.channel) try: - masklist = self.maskCache[key] + masklist = maskCache[key] except KeyError: if not (weechat.info_get('irc_is_channel', key[1]) and self.server): error("Command /%s must be used in an IRC buffer." % self.command) return + masklist = None self.clear() mask_count = 0 if masklist: mask_count = len(masklist) self.prnt('\n%s[%s %s]' %(color_channel, key[0], key[1])) - masks = [ m for m in masklist.itervalues() ] + masks = [ m for m in masklist.values() ] masks.sort(key=lambda x: x.date) for ban in masks: op = self.server @@ -2306,15 +2454,14 @@ self.prnt('No known %s for %s.%s' %(self.type, key[0], key[1])) if masklist is None or not masklist.synced: self.prnt("\n%sList not synced, please wait ..." %color_channel) - self.maskCache.fetch(key[0], key[1], lambda: self.execute()) + maskSync.fetch(key[0], key[1], self.mode, lambda: self.execute()) self.set_title('List of %s known by chanop in %s.%s (total: %s)' %(self.type, key[0], key[1], mask_count)) - -######################## -### Script callbacks ### +# ----------------------------------------------------------------------------- +# Script callbacks # Decorators def signal_parse(f): @@ -2329,7 +2476,7 @@ return WEECHAT_RC_OK nick = get_nick(signal_data) hostmask = signal_data[1:signal_data.find(' ')] - #debug('%s %s %s', data, signal, signal_data) + #debug('%s %s', signal, signal_data) return f(server, channel, nick, hostmask, signal_data) decorator.func_name = f.func_name return decorator @@ -2342,7 +2489,7 @@ channels = userCache.getChannels(server, nick) if channels: hostmask = signal_data[1:signal_data.find(' ')] - #debug('%s %s %s', data, signal, signal_data) + #debug('%s %s', signal, signal_data) return f(server, channels, nick, hostmask, signal_data) return WEECHAT_RC_OK decorator.func_name = f.func_name @@ -2369,7 +2516,7 @@ if '/VERSION' in isupport[server]: return '' buffer = weechat.buffer_search('irc', 'server.%s' %server) - weechat.command(buffer, '/VERSION') + weechat_command(buffer, '/VERSION') isupport[server]['/VERSION'] = True return v @@ -2454,7 +2601,7 @@ # check if channel is in watchlist key = (server, channel) allkeys = CaseInsensibleSet() - for maskCache in maskHandler.caches.itervalues(): + for maskCache in modeCache.values(): allkeys.update(maskCache) if key not in allkeys and key not in chanopChannels: # from a channel we're not tracking @@ -2470,7 +2617,7 @@ action = '' chanmode_list = [] args = args.split() - + # user channel mode, such as +v or +o, get only the letters and not the prefixes usermodes = ''.join(map(lambda c: c.isalpha() and c or '', prefix)) chanmodes = chanmodes.split(',') @@ -2491,21 +2638,21 @@ affected_users = [] # update masks for action, mode, mask in chanmode_list: - maskCache = maskHandler.caches[mode] - #debug('MODE: %s%s %s %s', action, mode, mask, op) + debug('MODE: %s%s %s %s', action, mode, mask, opHostmask) if action == '+': hostmask = hostmask_match_list(mask, userCache[key].hostmasks()) if hostmask: affected_users.extend(hostmask) - maskCache.add(server, channel, mask, operator=opHostmask, hostmask=hostmask) if mask != '*!*@*': # sending this signal with a *!*@* is annoying - weechat.hook_signal_send("%s,chanop_mode_%s" %(server, mode), - weechat.WEECHAT_HOOK_SIGNAL_STRING, - "%s %s %s %s" %(opHostmask, channel, mask, ','.join(hostmask))) - + weechat.hook_signal_send("%s,chanop_mode_%s" % (server, mode), + weechat.WEECHAT_HOOK_SIGNAL_STRING, + "%s %s %s %s" % (opHostmask, channel, + mask, ','.join(hostmask))) + modeCache.add(server, channel, mode, mask, operator=opHostmask, hostmask=hostmask) elif action == '-': - maskCache.remove(server, channel, mask) + modeCache.remove(server, channel, mode, mask) + if affected_users and get_config_boolean('display_affected', get_function=get_config_specific, server=server, channel=channel): buffer = weechat.buffer_search('irc', '%s.%s' %key) @@ -2551,18 +2698,27 @@ userCache[server, channel][newNick] = user return WEECHAT_RC_OK - # Garbage collector def garbage_collector_cb(data, counter): """This takes care of purging users and masks from channels not in watchlist, and expired users that parted. """ - maskHandler.purge() + debug('* flushing caches') + modeCache.purge() userCache.purge() - return WEECHAT_RC_OK + if weechat.config_get_plugin('debug'): + # extra check that everything is right. + for serv, chan in userCache: + for nick in [ nick['name'] for nick in nick_infolist(serv, chan) ]: + if nick not in userCache[serv, chan]: + error('User cache out of sync, unknown nick. (%s - %s.%s)' % (nick, serv, chan)) + return WEECHAT_RC_OK + +# ----------------------------------------------------------------------------- # Config callbacks + def enable_multi_kick_conf_cb(data, config, value): global cmd_kick, cmd_bankick cmd_kick.unhook() @@ -2590,8 +2746,45 @@ chanopChannels.update([ (server, channel) for channel in L ]) return WEECHAT_RC_OK +def enable_bar_cb(data, config, value): + if boolDict[value]: + chanop_bar.new() + weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '') + weechat.bar_item_new('chanop_status', 'item_status_cb', '') + weechat.hook_modifier('input_text_content', 'input_content_cb', '') + else: + chanop_bar.remove() + return WEECHAT_RC_OK + +def enable_debug_cb(data, config, value): + global debug + if value and boolDict[value]: + try: + # custom debug module I use, allows me to inspect script's objects. + import pybuffer + debug = pybuffer.debugBuffer(globals(), '%s_debug' % SCRIPT_NAME) + weechat.buffer_set(debug._getBuffer(), 'localvar_set_no_log', '0') + except: + def debug(s, *args): + if not isinstance(s, str): + s = str(s) + if args: + s = s % args + prnt('', '%s\t%s' % (script_nick, s)) + else: + try: + if hasattr(debug, 'close'): + debug.close() + except NameError: + pass + + debug = _no_debug + + return WEECHAT_RC_OK + +# ----------------------------------------------------------------------------- +# Completers -# WeeChat completions def cmpl_get_irc_users(f): """Check if completion is done in a irc channel, and pass the buffer's user list.""" @catchExceptions @@ -2605,7 +2798,7 @@ def unban_mask_cmpl(mode, completion_item, buffer, completion): """Completion for applied banmasks, for commands like /ounban /ounquiet""" - maskCache = maskHandler.caches[mode] + maskCache = modeCache[mode] key = irc_buffer(buffer) if not key: return WEECHAT_RC_OK @@ -2619,6 +2812,7 @@ pattern = '' #debug('%s %s', repr(input), repr(pattern)) if pattern and not is_nick(pattern): # FIXME nick completer interferes. + # NOTE masklist no longer accepts nicks. L = masklist.search(pattern) #debug('unban pattern %s => %s', pattern, L) if L: @@ -2628,28 +2822,44 @@ return elif not masklist: return - for mask in masklist.iterkeys(): + for mask in masklist.keys(): #debug('unban mask: %s', mask) weechat.hook_completion_list_add(completion, mask, 0, weechat.WEECHAT_LIST_POS_END) if key not in maskCache or not maskCache[key].synced: # do completion after fetching marks - if not maskHandler.queue: - def execute(): + if not maskSync.queue: + def callback(): masklist = maskCache[key] - if masklist: - say('Got %s +%s masks.' %(len(masklist), maskCache.mode), buffer) + if chanop_bar: + global chanop_bar_status + if masklist: + chanop_bar_status = 'Got %s +%s masks.' % (len(masklist), mode) + else: + chanop_bar_status = 'No +%s masks found.' % mode + chanop_bar.popup() + weechat.bar_item_update('chanop_status') else: - say('No +%s masks found.' %maskCache.mode, buffer) + if masklist: + say('Got %s +%s masks.' % (len(masklist), mode), buffer) + else: + say('No +%s masks found.' % mode, buffer) cmpl_unban(masklist) - maskCache.fetch(server, channel, execute) - say('Fetching +%s masks in %s, please wait...' %(mode, channel), buffer) + maskSync.fetch(server, channel, mode, callback) + if chanop_bar: + global chanop_bar_status + chanop_bar_status = 'Fetching +%s masks in %s, please wait...' %(mode, channel) + weechat.bar_item_update('chanop_status') + chanop_bar.popup() + else: + say('Fetching +%s masks in %s, please wait...' %(mode, channel), buffer) else: # mask list is up to date, do completion cmpl_unban(maskCache[key]) return WEECHAT_RC_OK +banmask_cmpl_list = [] @cmpl_get_irc_users def ban_mask_cmpl(users, data, completion_item, buffer, completion): """Completion for banmasks, for commands like /oban /oquiet""" @@ -2659,6 +2869,46 @@ return WEECHAT_RC_OK input, _, pattern = input.rpartition(' ') + + global banmask_cmpl_list + if is_hostmask(pattern): + if not banmask_cmpl_list: + maskList = pattern_match_list(pattern, users.hostmasks(sorted=True, all=True)) + if maskList: + banmask_cmpl_list = [ pattern ] + + def add(mask): + if mask not in banmask_cmpl_list: + banmask_cmpl_list.append(mask) + + for mask in maskList: + #debug('ban_mask_cmpl: Generating variations for %s', mask) + host = get_host(mask) + add('*!*@%s' % host) + add('%s!*@%s' % (get_nick(mask), host)) + if host.startswith('gateway/web/freenode'): + ip = host.partition('.')[2] + if is_ip(ip): + add('*!*@*%s' % ip) + elif is_ip(host): + user = get_user(mask) + iprange = host.rsplit('.', 2)[0] + add('*!%s@%s.*' % (user, iprange)) + add('*!*@%s.*' % iprange) + #debug('ban_mask_cmpl: variations: %s', banmask_cmpl_list) + + if pattern in banmask_cmpl_list: + i = banmask_cmpl_list.index(pattern) + 1 + if i == len(banmask_cmpl_list): + i = 0 + mask = banmask_cmpl_list[i] + input = '%s %s' % (input, mask) + weechat.buffer_set(buffer, 'input', input) + weechat.buffer_set(buffer, 'input_pos', str(len(input))) + return WEECHAT_RC_OK + + banmask_cmpl_list = [] + if pattern[-1] != '*': search_pattern = pattern + '*' else: @@ -2705,7 +2955,6 @@ weechat.hook_completion_list_add(completion, user, 0, weechat.WEECHAT_LIST_POS_END) return WEECHAT_RC_OK - # info hooks def info_hostmask_from_nick(data, info_name, arguments): #debug('INFO: %s %s', info_name, arguments) @@ -2731,11 +2980,114 @@ return '1' return '' +# ----------------------------------------------------------------------------- +# Chanop bar callbacks + +chanop_bar_current_buffer = '' + +@catchExceptions +def item_ban_matches_cb(data, item, window): + #debug('ban matches item: %s %s', item, window) + global chanop_bar_current_buffer + buffer = chanop_bar_current_buffer + if not buffer: + return '' + + input = weechat.buffer_get_string(buffer, 'input') + if not input: + return '' + + command, _, content = input.partition(' ') + + if command[1:] not in ('oban', 'oquiet'): + return '' + + def format(s): + return '%s affects: %s' % (command, s) + + channel = weechat.buffer_get_string(buffer, 'localvar_channel') + if not channel or not is_channel(channel): + return format('(not an IRC channel)') + + server = weechat.buffer_get_string(buffer, 'localvar_server') + users = userCache[server, channel] + content = content.split() + masks = [ mask for mask in content if is_hostmask(mask) or is_nick(mask) ] + if not masks: + return format('(no valid user mask or nick)') + + #debug('ban matches item: %s', masks) + + affected = [] + hostmasks = users.hostmasks(all=True) + for mask in masks: + if is_hostmask(mask): + affected.extend(hostmask_match_list(mask, hostmasks)) + elif mask in users: + affected.append(mask) + #debug('ban matches item: %s', affected) + + if not affected: + return format('(nobody)') + + L = set([ get_nick(h) for h in affected ]) + return format('(%s) %s' % (len(L), ' '.join(L))) + +chanop_bar_status = '' +def item_status_cb(data, item, window): + global chanop_bar_status + if chanop_bar_status: + return "%s[%s%s%s]%s %s" % (COLOR_BAR_DELIM, + COLOR_BAR_FG, + SCRIPT_NAME, + COLOR_BAR_DELIM, + color_reset, + chanop_bar_status) + else: + return "%s[%s%s%s]" % (COLOR_BAR_DELIM, + COLOR_BAR_FG, + SCRIPT_NAME, + COLOR_BAR_DELIM) + +@catchExceptions +def input_content_cb(data, modifier, modifier_data, string): + #debug('input_content_cb: %s %s %r', modifier, modifier_data, string) + global chanop_bar_current_buffer, chanop_bar_status + if not chanop_bar: + return string + + if string and not weechat.string_input_for_buffer(string): + command, _, content = string.partition(' ') + content = content.strip() + if content and command[1:] in ('oban', 'oquiet'): + chanop_bar.show() + chanop_bar_current_buffer = modifier_data + weechat.bar_item_update('chanop_ban_matches') + if chanop_bar_status: + chanop_bar_status = '' + weechat.bar_item_update('chanop_bar_status') + return string + + if not chanop_bar._timer_hook: + chanop_bar.hide() + return string + +# ----------------------------------------------------------------------------- +# Main + +def unload_chanop(): + if chanop_bar: + # we don't remove it, so custom options configs aren't lost + chanop_bar.hide() + bar_item = weechat.bar_item_search('chanop_ban_matches') + if bar_item: + weechat.bar_item_remove(bar_item) + return WEECHAT_RC_OK # Register script if __name__ == '__main__' and import_ok and \ weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, - SCRIPT_DESC, '', ''): + SCRIPT_DESC, 'unload_chanop', ''): # colors color_delimiter = weechat.color('chat_delimiters') @@ -2744,6 +3096,10 @@ color_mask = weechat.color('white') color_channel = weechat.color('lightred') color_reset = weechat.color('reset') + COLOR_WHITE = weechat.color('white') + COLOR_DARKGRAY = weechat.color('darkgray') + COLOR_BAR_DELIM = weechat.color('bar_delim') + COLOR_BAR_FG = weechat.color('bar_fg') # pretty [chanop] script_nick = '%s[%s%s%s]%s' %(color_delimiter, @@ -2752,15 +3108,23 @@ color_delimiter, color_reset) + # ------------------------------------------------------------------------- + # Debug + + enable_debug_cb('', '', weechat.config_get_plugin('debug')) + weechat.hook_config('plugins.var.python.%s.debug' % SCRIPT_NAME, 'enable_debug_cb', '') + + # ------------------------------------------------------------------------- + # Init + # check weechat version try: version = int(weechat.info_get('version_number', '')) except: version = 0 - #debug(version) - if version < 0x30200: - error('WeeChat < 0.3.2: using irc_is_nick workaround.') - is_nick = _is_nick # prior to 0.3.2 didn't have irc_is_nick info + if version < WEECHAT_VERSION[0]: + error("This version of WeeChat isn't supported. Use %s or later." % WEECHAT_VERSION[1]) + raise Exception('unsupported weechat version') if version < 0x30300: # prior to 0.3.3 didn't have support for ISUPPORT msg error('WeeChat < 0.3.3: using ISUPPORT workaround.') weechat.hook_signal('*,irc_in_005', 'isupport_cb', '') @@ -2768,10 +3132,38 @@ error('WeeChat < 0.3.4: using irc_nick infolist workaround.') Infolist._use_flags = True - for opt, val in settings.iteritems(): + for opt, val in settings.items(): if not weechat.config_is_set_plugin(opt): weechat.config_set_plugin(opt, val) + modeCache = ModeCache('chanop_mode_cache.dat') + modeCache.registerMode('b', 'ban', 'bans') + modeCache.registerMode('q', 'quiet', 'quiets') + + # ------------------------------------------------------------------------- + # remove old chanmask config and save them in shelf + + prefix = 'python.%s.chanmask' % SCRIPT_NAME + infolist = Infolist('option', 'plugins.var.%s.*' % prefix) + n = len(prefix) + while infolist.next(): + option = infolist['option_name'][n + 1:] + server, channel, mode, mask = option.split('.', 3) + if mode in modeCache: + cache = modeCache[mode] + if (server, channel) in cache: + masklist = cache[server, channel] + else: + masklist = cache[server, channel] = MaskList(server, channel) + if mask in masklist: + masklist[mask].deserialize(infolist['value']) + else: + obj = masklist[mask] = MaskObject(mask) + obj.deserialize(infolist['value']) + weechat.config_unset_plugin('chanmask.%s.%s.%s.%s' \ + % (server, channel, mode, mask)) + del infolist + # hook /oop /odeop Op().hook() Deop().hook() @@ -2798,12 +3190,14 @@ Voice().hook() DeVoice().hook() - maskHandler.hook() + maskSync.hook() - weechat.hook_config('plugins.var.python.%s.enable_multi_kick' %SCRIPT_NAME, + weechat.hook_config('plugins.var.python.%s.enable_multi_kick' % SCRIPT_NAME, 'enable_multi_kick_conf_cb', '') - weechat.hook_config('plugins.var.python.%s.watchlist.*' %SCRIPT_NAME, + weechat.hook_config('plugins.var.python.%s.watchlist.*' % SCRIPT_NAME, 'update_chanop_watchlist_cb', '') + weechat.hook_config('plugins.var.python.%s.enable_bar' % SCRIPT_NAME, + 'enable_bar_cb', '') weechat.hook_completion('chanop_unban_mask', 'channelmode b masks', 'unban_mask_cmpl', 'b') weechat.hook_completion('chanop_unquiet_mask', 'channelmode q masks', 'unban_mask_cmpl', 'q') @@ -2819,7 +3213,17 @@ weechat.hook_signal('*,irc_in_mode', 'mode_cb', '') # run our cleaner function every 30 min. - weechat.hook_timer(30*60*1000, 0, 0, 'garbage_collector_cb', '') + weechat.hook_timer(1000 * 60 * 30, 0, 0, 'garbage_collector_cb', '') + + chanop_bar = PopupBar('chanop_bar', hidden=True, + items='chanop_status,chanop_ban_matches') + if get_config_boolean('enable_bar'): + chanop_bar.new() + weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '') + weechat.bar_item_new('chanop_status', 'item_status_cb', '') + weechat.hook_modifier('input_text_content', 'input_content_cb', '') + else: + chanop_bar.remove() weechat.hook_info("chanop_hostmask_from_nick", "Returns nick's hostmask if is known. Returns '' otherwise.", @@ -2828,26 +3232,5 @@ "Test if pattern matches text, is case insensible with IRC case rules.", "pattern,text", "info_pattern_match", "") - # ------------------------------------------------------------------------- - # 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: diff -Nru weechat-scripts-20130123/python/clone_scanner.py weechat-scripts-20131007/python/clone_scanner.py --- weechat-scripts-20130123/python/clone_scanner.py 2013-01-23 19:00:15.000000000 +0000 +++ weechat-scripts-20131007/python/clone_scanner.py 2013-10-07 12:14:47.000000000 +0000 @@ -1,13 +1,13 @@ # -*- coding: utf-8 -*- # -# Clone Scanner, version 1.1 for WeeChat version 0.3 +# Clone Scanner, version 1.3 for WeeChat version 0.3 # Latest development version: https://github.com/FiXato/weechat_scripts # -# A Clone Scanner that can manually scan channels and -# automatically scans joins for users on the channel +# A Clone Scanner that can manually scan channels and +# automatically scans joins for users on the channel # with multiple nicknames from the same host. # -# Upon join by a user, the user's host is compared to the infolist of +# Upon join by a user, the user's host is compared to the infolist of # already connected users to see if they are already online from # another nickname. If the user is a clone, it will report it. # With the '/clone_scanner scan' command you can manually scan a chan. @@ -28,7 +28,7 @@ # ## History: ### 2011-09-11: FiXato: -# +# # * version 0.1: initial release. # * Added an on-join clone scan. Any user that joins a channel will be # matched against users already on the channel. @@ -101,14 +101,25 @@ # * Continuing to fix the on-join scanner bugs introduced by the 0.9 release. # The ident@host.name dict key wasn't being lowercased for comparison in the on-join scan. # +# * version 1.2: So shameless! +# * Added shameless advertising for my script through /clone_scanner advertise +# +### 2013-04-09: FiXato: +# * version 1.3: Such a killer rabbit +# * Thanks to Curtis Sorensen aka killerrabbit clone_scanner.py now supports: +# * local channels (&-prefixed) +# * nameless channels (just # or &) +# ## Acknowledgements: # * Sebastien "Flashcode" Helleu, for developing the kick-ass chat/IRC # client WeeChat # * ArZa, whose kickban.pl script helped me get started with using the -# infolist results. +# infolist results. # * LayBot, for requesting the ident comparison +# * Curtis "killerrabbit" Sorensen, for sending in two pull-requests, +# adding support for local and nameless channels. # -## TODO: +## TODO: # - Add option to enable/disable public clone reporting aka msg channels # - Add option to enable/disable scanning on certain channels/networks # - Add cross-channel clone scan @@ -139,7 +150,7 @@ # SCRIPT_NAME = "clone_scanner" SCRIPT_AUTHOR = "Filip H.F. 'FiXato' Slagter " -SCRIPT_VERSION = "1.1" +SCRIPT_VERSION = "1.3" SCRIPT_LICENSE = "MIT" SCRIPT_DESC = "A Clone Scanner that can manually scan channels and automatically scans joins for users on the channel with multiple nicknames from the same host." SCRIPT_COMMAND = "clone_scanner" @@ -186,7 +197,7 @@ ("colors.clone_report.subheader.message", "chat", "The colour of the clone report subheader."), ("colors.clone_report.subheader.host", "bold", "The colour of the host in the clone report subheader."), ("colors.clone_report.subheader.number_of_clones", "bold", "The colour of the number of clones in the clone report subheader."), - + ("colors.clone_report.clone.message", "chat", "The colour of the clone hit in the clone report message."), ("colors.clone_report.clone.match", "chat", "The colour of the match details (masks or nicks) in the clone report."), @@ -224,7 +235,7 @@ def on_join_scan_cb(data, signal, signal_data): network = signal.split(',')[0] joined_nick = weechat.info_get("irc_nick_from_host", signal_data) - join_match_data = re.match(':[^!]+!([^@]+@(\S+)) JOIN :?(#\S+)', signal_data) + join_match_data = re.match(':[^!]+!([^@]+@(\S+)) JOIN :?([#&]\S*)', signal_data) parsed_ident_host = join_match_data.group(1).lower() parsed_host = join_match_data.group(2).lower() if weechat.config_get_plugin("compare_idents") == "on": @@ -309,11 +320,11 @@ if not channel_name: channel_name = weechat.buffer_get_string(buffer, "localvar_channel") - match_data = re.match('\A(irc.)?([^.]+)\.(#\S+)\Z', channel_name) + match_data = re.match('\A(irc.)?([^.]+)\.([#&]\S*)\Z', channel_name) if match_data: channel_name = match_data.group(3) server_name = match_data.group(2) - + return server_name, channel_name def get_clones_for_buffer(infolist_buffer_name, hostname_to_match=None): @@ -340,7 +351,7 @@ matches.setdefault(hostkey,[]).append({ 'nick': nick, 'mask': "%s!%s" % ( - format_from_config(nick, "colors.mask.nick"), + format_from_config(nick, "colors.mask.nick"), format_from_config(ident_hostname, "colors.mask.identhost")), 'ident': ident, 'ident_hostname': ident_hostname, @@ -385,7 +396,7 @@ weechat.prnt(target_buffer, "No clones found on %s" % scanned_buffer_name) def cs_command_main(data, buffer, args): - if args[0:4] == 'scan': + if args[0:4] == 'scan': server_name, channel_name = get_channel_from_buffer_args(buffer, args[5:]) clones = get_clones_for_buffer('%s,%s' % (server_name, channel_name)) if weechat.config_get_plugin("display_scan_report_target_buffer") == "on": @@ -395,6 +406,8 @@ report_clones(clones, '%s.%s' % (server_name, channel_name)) if weechat.config_get_plugin("display_scan_report_current_buffer") == "on": report_clones(clones, '%s.%s' % (server_name, channel_name), weechat.current_buffer()) + elif args[0:9] == 'advertise': + weechat.command("", "/input insert /me is using FiXato's CloneScanner v%s for WeeChat. Get the latest version from: https://github.com/FiXato/weechat_scripts/blob/master/clone_scanner.py" % SCRIPT_VERSION) return weechat.WEECHAT_RC_OK def cs_set_default_settings(): @@ -415,9 +428,9 @@ cs_buffer = weechat.buffer_search("python", "clone_scanner") weechat.hook_signal("*,irc_in2_join", "on_join_scan_cb", "") - weechat.hook_command(SCRIPT_COMMAND, + weechat.hook_command(SCRIPT_COMMAND, SCRIPT_DESC, - "[scan] [[plugin.][network.]channel] | [help]", + "[scan] [[plugin.][network.]channel] | [advertise] | [help]", "the target_buffer can be: \n" "- left out, so the current channel buffer will be scanned.\n" "- a plain channel name, such as #weechat, in which case it will prefixed with the current network name\n" @@ -426,6 +439,7 @@ "See /set plugins.var.python.clone_scanner.* for all possible configuration options", " || scan %(buffers_names)" + " || advertise" " || help", "cs_command_main", "") diff -Nru weechat-scripts-20130123/python/cmus.py weechat-scripts-20131007/python/cmus.py --- weechat-scripts-20130123/python/cmus.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/cmus.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,130 @@ +# Copyright (C) 2013 - Isaac Ross +# +# 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 2 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 + +# Made as a port of cmus_xchat-v2.0, also made by Isaac Ross. Due to the nature of weechat's plugin/scripting API, +# this was mostly made using find/replace in a text editor + +import commands +import weechat +import os + +weechat.register("cmus", "Isaac Ross", "1.02", "GPL2", "Adds ability to control cmus and post the currently playing song in a channel", "", "") + + +def help(): + weechat.prnt('', ' --Option-- --Command--') + weechat.prnt('', '-Play: /cmus play') + weechat.prnt('', '-Pause: /cmus pause') + weechat.prnt('', '-Stop: /cmus stop') + weechat.prnt('', '-Next Track: /cmus next') + weechat.prnt('', '-Previous Track: /cmus prev') + weechat.prnt('', '-Toggle Shuffle: /cmus shuffle') + weechat.prnt('', '-Player Status: /cmus status') + weechat.prnt('', '-Now Playing: /cmusnp') + weechat.prnt('', '-NP (filename): /cmus file') + weechat.prnt('', ' ') + weechat.prnt('', "-NOTE: If the currently playing file lacks artist, album, and title tags, use '/cmus file' to post the filename instead.") + weechat.prnt('', '----------------------------------------------------------------------------------------') + weechat.prnt('', "If you encounter any problems, feel free to email me at: ") + weechat.prnt('', "Keep in mind that most problems will probably be related to cmus-remote, not this script") + +def np(): + cmus = commands.getoutput('cmus-remote -Q') + lines = cmus.split('\n') + + #some redundant loops later, but streamline as needed + + #Only store lines marked as tags + tags = [line.split(' ')[1:] for line in lines if line[:3] == 'tag'] + + title, artist, album = '', '', '' + for tag in tags: + if tag[0] == 'artist': + artist = ' '.join(tag[1:]) + elif tag[0] == 'title': + title = ' '.join(tag[1:]) + elif tag[0] == 'album': + album = ' '.join(tag[1:]) + else: + #Maybe eventually extend the functionality to print other tags? + continue + + nowplaying = "%(artist)s - %(title)s (album: %(album)s)" % \ + {"artist": artist, \ + "title": title, \ + "album": album} + + return nowplaying + +def control(data, buffer, args): + args = args.split(' ') + if args[0].lower() == 'play': + os.system('cmus-remote -p') + weechat.prnt('', 'Playing...') + elif args[0].lower() == 'pause': + os.system('cmus-remote -u') + weechat.prnt('', 'Paused.') + elif args[0].lower() == 'stop': + os.system('cmus-remote -s') + weechat.prnt('', 'Stopped.') + elif args[0].lower() == 'next': + os.system('cmus-remote -n') + weechat.prnt('', 'Playing next track...') + elif args[0].lower() == 'prev': + os.system('cmus-remote -r') + weechat.prnt('', 'Playing previous track...') + elif args[0].lower() == 'shuffle': + os.system('cmus-remote -S') + weechat.prnt('', 'Toggled shuffle on/off.') + elif args[0].lower() == 'status': + status = commands.getoutput('cmus-remote -Q') + status = status.split('\n') + for line in status: + weechat.prnt('', " -- " + line) + elif args[0].lower() == 'help': + help() + elif args[0].lower() == 'file': + filename = commands.getoutput('cmus-remote -Q') + filename = filename.split('\n') + newname = filename[1] + newname = newname.replace('file', '', 1) + newname = newname.replace(' ', '', 1) + newname = newname.rpartition('/') + newname = newname[-1] + weechat.command('', '/me is currently listening to: ' + newname) + else: + weechat.prnt('', 'Not a valid option.') + help() + return weechat.WEECHAT_RC_OK + +def weechat_np(data, buffer, args): + weechat.command(buffer, '/me is currently listening to: ' + np()) + return weechat.WEECHAT_RC_OK + +weechat.hook_command("cmusnp", "Get/send now playing info.", "", "", "", "weechat_np", "") +weechat.hook_command("cmus", "Control cmus.", "[file] | [next] | [pause] | [play] | [prev] | [shuffle] | [status] | [stop] | [help]", +""" +file: Get/send name of the currently playing file. +next: Play next file. +pause: Pause playback. +play: Resume playback. +prev: Play previous song. +shuffle: Enable shuffle. +status: Show status of cmus (same as "cmus-remote -Q" in your shell) +stop: Stop playback. +help: Alternative (original) help list. + +Use /cmusnp if you're looking for the now-playing functionality of the script. +""" , "", "control", "") diff -Nru weechat-scripts-20130123/python/colorize_nicks.py weechat-scripts-20131007/python/colorize_nicks.py --- weechat-scripts-20130123/python/colorize_nicks.py 2013-01-23 19:00:11.000000000 +0000 +++ weechat-scripts-20131007/python/colorize_nicks.py 2013-10-07 12:14:43.000000000 +0000 @@ -21,6 +21,8 @@ # # # History: +# 2013-01-29, nils_2 +# version 14: make script compatible with Python 3.x # 2012-10-19, ldvx # version 13: Iterate over every word to prevent incorrect colorization of # nicks. Added option greedy_matching. @@ -58,7 +60,7 @@ SCRIPT_NAME = "colorize_nicks" SCRIPT_AUTHOR = "xt " -SCRIPT_VERSION = "13" +SCRIPT_VERSION = "14" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "Use the weechat nick colors in the chat area" @@ -290,11 +292,13 @@ if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "", ""): # Set default settings - for option, default_value in settings.iteritems(): +# for option, default_value in settings.iteritems(): + for option, default_value in list(settings.items()): if not w.config_is_set_plugin(option): w.config_set_plugin(option, default_value) - for key, value in PREFIX_COLORS.iteritems(): + for key, value in list(PREFIX_COLORS.items()): +# for key, value in PREFIX_COLORS.iteritems(): PREFIX_COLORS[key] = w.color(w.config_string(w.config_get('weechat.look.%s'%value))) update_blacklist() # Set blacklist diff -Nru weechat-scripts-20130123/python/confversion.py weechat-scripts-20131007/python/confversion.py --- weechat-scripts-20130123/python/confversion.py 2013-01-23 19:00:12.000000000 +0000 +++ weechat-scripts-20131007/python/confversion.py 2013-10-07 12:14:44.000000000 +0000 @@ -19,11 +19,13 @@ # Allows you to visually see if there are updates to your weechat system #Versions -# 0.1 drubin - First release. -# - Basic functionality to save version history of your config files (only git, bzr) +# 0.1 drubin - First release. +# - Basic functionality to save version history of your config files (only git, bzr) +# 0.2 ShockkPony - Fixed massive weechat startup time caused by initial config loading + SCRIPT_NAME = "confversion" SCRIPT_AUTHOR = "drubin " -SCRIPT_VERSION = "0.1" +SCRIPT_VERSION = "0.2" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Stores version controlled history of your configuration files" @@ -35,8 +37,8 @@ print "This script must be run under WeeChat." print "Get WeeChat now at: http://www.weechat.org/" import_ok = False - - + + # script options settings = { #Currently supports git and bzr and possibly other that support simple "init" "add *.conf" "commit -m "message" " @@ -69,11 +71,32 @@ #Save first import OR on start up if needed. commit_cb() +confversion_commit_finish_hook = 0 + def commit_cb(data=None, remaning=None): - #Save configs before doing commit + global confversion_commit_finish_hook + + # only hook timer if not already hooked + if confversion_commit_finish_hook == 0: + confversion_commit_finish_hook = weechat.hook_timer(500, 0, 1, "commit_cb_finish", "") + + return weechat.WEECHAT_RC_OK + +def commit_cb_finish(data=None, remaining=None): + global confversion_commit_finish_hook + + # save before doing commit weechat.command("","/save") + + # add all config changes to git shell_in_home("add ./*.conf") - shell_in_home("commit -m \"%s\"" % weechat.config_get_plugin("commit_message")) + + # do the commit + shell_in_home("commit -m \"%s\"" % weechat.config_get_plugin("commit_message")) + + # set hook back to 0 + confversion_commit_finish_hook = 0 + return weechat.WEECHAT_RC_OK def conf_update_cb(data, option, value): @@ -83,7 +106,7 @@ #This is kinda hack but better input would be appricated. weechat.hook_timer(500, 0, 1, "commit_cb", "") return weechat.WEECHAT_RC_OK - + def confversion_cmd(data, buffer, args): commit_cb() return weechat.WEECHAT_RC_OK @@ -93,9 +116,9 @@ for option, default_value in settings.iteritems(): if weechat.config_get_plugin(option) == "": weechat.config_set_plugin(option, default_value) - + weechat.hook_command("confversion", "Saves configurations to version control", "", "", - "", "confversion_cmd", "") - init_repo() + "", "confversion_cmd", "") + init_repo() hook = weechat.hook_config("*", "conf_update_cb", "") diff -Nru weechat-scripts-20130123/python/country.py weechat-scripts-20131007/python/country.py --- weechat-scripts-20130123/python/country.py 2013-01-23 19:00:08.000000000 +0000 +++ weechat-scripts-20131007/python/country.py 2013-10-07 12:14:41.000000000 +0000 @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- ### # Copyright (c) 2009-2011 by Elián Hanisch +# Copyright (c) 2013 by Filip H.F. "FiXato" Slagter # # 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 @@ -47,6 +48,13 @@ # # # History: +# 2013-04-28 +# version 0.6: +# * Improved support for target msgbuffer. Takes the following settings into account: +# - irc.msgbuffer.whois +# - irc.msgbuffer.$servername.whois +# - irc.look.msgbuffer_fallback +# # 2011-08-14 # version 0.5: # * make time format configurable. @@ -80,7 +88,7 @@ SCRIPT_NAME = "country" SCRIPT_AUTHOR = "Elián Hanisch " -SCRIPT_VERSION = "0.5" +SCRIPT_VERSION = "0.6" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Prints user's country and local time in whois replies" SCRIPT_COMMAND = "country" @@ -109,7 +117,7 @@ ### config settings = { 'time_format': '%x %X %Z', - 'show_in_whois': 'on', + 'show_in_whois': 'on', 'show_localtime': 'on' } @@ -145,18 +153,18 @@ prefix_network = weechat.prefix('network') color_delimiter = weechat.color('chat_delimiters') color_nick = weechat.color('chat_nick') - prnt(buffer, '%s%s[%s%s%s] %s' % (prefix_network, - color_delimiter, - color_nick, + prnt(buffer, '%s%s[%s%s%s] %s' % (prefix_network, + color_delimiter, + color_nick, nick, - color_delimiter, + color_delimiter, string)) def string_country(country, code): """Format for country info string.""" color_delimiter = weechat.color('chat_delimiters') color_chat = weechat.color('chat') - return '%s%s %s(%s%s%s)' % (color_chat, + return '%s%s %s(%s%s%s)' % (color_chat, country, color_delimiter, color_chat, @@ -473,6 +481,29 @@ print_country(host, buffer) return WEECHAT_RC_OK +def find_buffer(server, nick, message_type='whois'): + # See if there is a target msgbuffer set for this server + msgbuffer = weechat.config_string(weechat.config_get('irc.msgbuffer.%s.%s' % (server, message_type))) + # No whois msgbuffer for this server; use the global setting + if msgbuffer == '': + msgbuffer = weechat.config_string(weechat.config_get('irc.msgbuffer.%s' % message_type)) + + # Use the fallback msgbuffer setting if private buffer doesn't exist + if msgbuffer == 'private': + buffer = weechat.buffer_search('irc', '%s.%s' %(server, nick)) + if buffer != '': + return buffer + else: + msgbuffer = weechat.config_string(weechat.config_get('irc.look.msgbuffer_fallback')) + + # Find the appropriate buffer + if msgbuffer == "current": + return weechat.current_buffer() + elif msgbuffer == "weechat": + return weechat.buffer_search_main() + else: + return weechat.buffer_search('irc', 'server.%s' % server) + ### signal callbacks def whois_cb(data, signal, signal_data): """function for /WHOIS""" @@ -481,11 +512,8 @@ nick, user, host = signal_data.split()[3:6] server = signal[:signal.find(',')] #debug('%s | %s | %s' %(data, signal, signal_data)) - buffer = weechat.buffer_search('irc', '%s.%s' %(server, nick)) - if weechat.config_string(weechat.config_get('irc.msgbuffer.whois')) != "private" or buffer == "": - buffer = weechat.buffer_search('irc', 'server.%s' %server) host = get_ip_from_userhost(user, host) - print_country(host, buffer, quiet=True, broken=True, nick=nick) + print_country(host, find_buffer(server, nick), quiet=True, broken=True, nick=nick) return WEECHAT_RC_OK ### main diff -Nru weechat-scripts-20130123/python/facebook_rename.py weechat-scripts-20131007/python/facebook_rename.py --- weechat-scripts-20130123/python/facebook_rename.py 2013-01-23 19:00:10.000000000 +0000 +++ weechat-scripts-20131007/python/facebook_rename.py 2013-10-07 12:14:43.000000000 +0000 @@ -1,7 +1,7 @@ -# This script renames your Facebook buddies to a readable format when -# using Facebook's XMPP gateway with Bitlbee or Minbif. +# This script renames your Facebook buddies to a readable format when +# using Facebook's XMPP gateway with Bitlbee or Minbif. -# Based on the Irssi script at http://browsingtheinternet.com/temp/bitlbee_rename.txt +# Based on the Irssi script at http://browsingtheinternet.com/temp/bitlbee_rename.txt # Ported for Weechat 0.3.0 or later by Jaakko Lintula (crwl@iki.fi) # Modified for Minbif by 'varogami' # Testing contrib 'bizio' @@ -10,7 +10,12 @@ # Edit this variables with your own minbif configuration settings -mode = "bitlbee" # set 'bitlbee' or 'minbif' to select gateway type + +# Set the first word in full name string that "/WHOIS nick nick" or /WII show +# italian - fullname="Nome" +# spanish - fullname="Nombre completo" +fullname="Name" +mode = "minbif" # set 'bitlbee' or 'minbif' to select gateway type minbifChannel = "&minbif" minbifServer = "minbif" bitlbeeChannel = "&bitlbee" @@ -24,7 +29,7 @@ import weechat import re -weechat.register("facebook_rename", "crwl", "1.1", "Public Domain", "Renames Facebook usernames when using Bitlbee or Minbif", "", "") +weechat.register("facebook_rename", "crwl", "1.1.2", "Public Domain", "Renames Facebook usernames when using Bitlbee or Minbif", "", "") def message_join_minbif(data, signal, signal_data): signal_data = signal_data.split() @@ -33,24 +38,25 @@ nick = hostmask[1:hostmask.index('!')] username = hostmask[hostmask.index('!')+1:hostmask.index('@')] server = hostmask[hostmask.index('@')+1:] - server = server[:+server.index(':')] - + if server.find(':') > 1: + server = server[:+server.index(':')] + if channel == minbifChannel and nick == username and nick[0] == '-' and server == facebookhostname: nicksToRename.add(nick) weechat.command(weechat.buffer_search("irc", minbifBuffer), "/whois "+nick+" "+nick) - + return weechat.WEECHAT_RC_OK def whois_data_minbif(data, signal, signal_data): - if "Full Name" in signal_data: - nick = signal_data.split("Full Name:")[0].strip() + if fullname in signal_data: + nick = signal_data.split(fullname)[0].strip() nick = nick[1:nick.index(' :')] nick = nick.split(' ') nick = nick[3] - realname = signal_data.split("Full Name:")[1].strip() - + realname = signal_data.split(fullname)[1].strip() + if nick in nicksToRename: - nicksToRename.remove(nick) + nicksToRename.remove(nick) ircname = re.sub("[^A-Za-z0-9]", "", realname)[:24] if ircname != nick: weechat.command(weechat.buffer_search("irc", minbifBuffer), "/quote -server %s svsnick %s %s" % (minbifServer, nick, ircname)) @@ -64,25 +70,25 @@ nick = hostmask[1:hostmask.index('!')] username = hostmask[hostmask.index('!')+1:hostmask.index('@')] server = hostmask[hostmask.index('@')+1:] - - if channel == bitlbeeChannel and nick == username and nick[0] == '-' and server == facebookhostname: + + if channel == bitlbeeChannel and nick == username and nick[0] == '-' and server == facebookhostname: nicksToRename.add(nick) weechat.command(weechat.buffer_search("irc", bitlbeeBuffer), "/whois " + nick) - + return weechat.WEECHAT_RC_OK def whois_data_bitlbee(data, signal, signal_data): nick = signal_data.split()[3] realname = signal_data[signal_data.rindex(':')+1:] - + if nick in nicksToRename: nicksToRename.remove(nick) - + ircname = re.sub("[^A-Za-z0-9]", "", realname)[:24] if ircname != nick: weechat.command(weechat.buffer_search("irc", bitlbeeBuffer), "/msg %s rename %s %s" % (bitlbeeChannel, nick, ircname)) weechat.command(weechat.buffer_search("irc", bitlbeeBuffer), "/msg %s save" % (bitlbeeChannel)) - + return weechat.WEECHAT_RC_OK if mode == "minbif": diff -Nru weechat-scripts-20130123/python/fish.py weechat-scripts-20131007/python/fish.py --- weechat-scripts-20130123/python/fish.py 2013-01-23 19:00:17.000000000 +0000 +++ weechat-scripts-20131007/python/fish.py 2013-10-07 12:14:48.000000000 +0000 @@ -51,7 +51,7 @@ SCRIPT_NAME = "fish" SCRIPT_AUTHOR = "David Flatz " -SCRIPT_VERSION = "0.6" +SCRIPT_VERSION = "0.7" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "FiSH for weechat" CONFIG_FILE_NAME = SCRIPT_NAME @@ -148,8 +148,8 @@ fish_config_option["mark_position"] = weechat.config_new_option( fish_config_file, fish_config_section["look"], "mark_position", - "string", "put marker for encrypted INCOMING messages at start or end", "off|begin|end", - 0,0, "off", "off", 0, "", "", "", "", "", "") + "integer", "put marker for encrypted INCOMING messages at start or end", "off|begin|end", + 0,2, "off", "off", 0, "", "", "", "", "", "") fish_config_option["mark_encrypted"] = weechat.config_new_option( fish_config_file, fish_config_section["look"], "mark_encrypted", @@ -283,7 +283,7 @@ except ValueError: raise MalformedError - return plain.strip('\x00') + return plain.strip('\x00').replace('\n','') # @@ -814,8 +814,10 @@ pos = args.find(" ") if pos: pos = args.find(" ", pos + 1) - if pos: + if pos > 0: argv2eol = args[pos + 1:] + else: + argv2eol = args[args.find(" ") +1:] target = "%s/%s" % (server_name, target_user) diff -Nru weechat-scripts-20130123/python/histman.py weechat-scripts-20131007/python/histman.py --- weechat-scripts-20130123/python/histman.py 2013-01-23 19:00:18.000000000 +0000 +++ weechat-scripts-20131007/python/histman.py 2013-10-07 12:14:50.000000000 +0000 @@ -17,6 +17,9 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-01-25: nils_2 (freenode.#weechat) +# 0.4 : make script compatible with Python 3.x +# # 2013-01-20: nils_2, (freenode.#weechat) # 0.3: fix wrong command argument in help-text # @@ -37,13 +40,13 @@ import weechat,re,os except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = 'histman' SCRIPT_AUTHOR = 'nils_2 ' -SCRIPT_VERSION = '0.3' +SCRIPT_VERSION = '0.4' SCRIPT_LICENSE = 'GPL' SCRIPT_DESC = 'save and restore global and/or buffer command history' @@ -221,8 +224,9 @@ return try: - f = open(filename, 'rb') - for line in f.xreadlines(): + f = open(filename, 'r') +# for line in f.xreadlines(): # old python 2.x + for line in f: # should also work with python 2.x # line = line.decode('utf-8') line = str(line.strip()) if ptr_buffer: @@ -347,7 +351,7 @@ # ================================[ weechat options & description ]=============================== def init_options(): - for option,value in OPTIONS.items(): + for option,value in list(OPTIONS.items()): if not weechat.config_is_set_plugin(option): weechat.config_set_plugin(option, value[0]) weechat.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) diff -Nru weechat-scripts-20130123/python/im_kayac_com_notify.py weechat-scripts-20131007/python/im_kayac_com_notify.py --- weechat-scripts-20130123/python/im_kayac_com_notify.py 2013-01-23 19:00:16.000000000 +0000 +++ weechat-scripts-20131007/python/im_kayac_com_notify.py 2013-10-07 12:14:48.000000000 +0000 @@ -2,7 +2,7 @@ """ Author: Gosuke Miyashita Homepage: https://github.com/mizzy/weechat-plugins/ -Version: 1.0 +Version: 1.2 License: MIT License This plugin is for pushing notifications to im.kayac.com. @@ -24,35 +24,49 @@ import weechat import urllib +import hashlib ## registration -weechat.register("im_kayac_com_notify", "Gosuke Miyashita", "1.0", "MIT License", +weechat.register("im_kayac_com_notify", "Gosuke Miyashita", "1.2", "MIT License", "im_kayac_com_notify: Push notification to iPod touch/iPhone with im.kayac.com", "", "") ## settings script_options = { - "username": "", - "password": "" + "username": "", + "password": "", + "secretkey": "", } -for option, default_value in script_options.items(): - if weechat.config_get_plugin(option) == "": - weechat.prnt("", weechat.prefix("error") + "im_kayac_com_notify: Please set option: %s" % option) - weechat.prnt("", "im_kayac_com_notify: /set plugins.var.python.im_kayac_com_notify.%s STRING" % option) +if weechat.config_get_plugin("username") == "": + weechat.prnt("", weechat.prefix("error") + "im_kayac_com_notify: Please set option: username") + weechat.prnt("", "im_kayac_com_notify: /set plugins.var.python.im_kayac_com_notify.username STRING") + +if weechat.config_get_plugin("password") == "" and weechat.config_get_plugin("secretkey") == "": + weechat.prnt("", weechat.prefix("error") + "im_kayac_com_notify: Please set option: password or secretkey") + weechat.prnt("", "im_kayac_com_notify: /set plugins.var.python.im_kayac_com_notify.[password|secretkey] STRING") ## functions -def postIm(message, handler=None, label=None, title=None): - USERNAME = weechat.config_get_plugin("username") - PASSWORD = weechat.config_get_plugin("password") - if USERNAME != "" and PASSWORD != "": +def postIm(message, handler=None, label=None, title=None, buffer_name=None, prefix=None): + USERNAME = weechat.config_get_plugin("username") + PASSWORD = weechat.config_get_plugin("password") + SECRETKEY = weechat.config_get_plugin("secretkey") + + if USERNAME != "": url = "http://im.kayac.com/api/post/" + USERNAME opt_dict = { - "message": "[%s] - %s\n%s" % (label, title, message), - "password": PASSWORD, + "message": "[%s][%s] - %s\n%s %s" % (label, buffer_name, title, prefix, message), } + + if PASSWORD != "": + opt_dict["password"] = PASSWORD + elif SECRETKEY != "": + opt_dict["sig"] = hashlib.sha1(opt_dict["message"] + SECRETKEY).hexdigest() + else: + return + opt = urllib.urlencode(opt_dict) cmd = "python -c 'from urllib2 import Request, urlopen; urlopen(Request(\"%s\", \"%s\"))'" % (url, opt) weechat.hook_process(cmd, 10000, "hook_process_cb", "") @@ -60,13 +74,13 @@ def hook_process_cb(data, command, rc, stdout, stderr): return weechat.WEECHAT_RC_OK -def signal_callback(data, signal, signal_data): - if signal == "weechat_pv": - postIm(signal_data, label="weechat", title="Private Message") - elif signal == "weechat_highlight": - postIm(signal_data, label="weechat", title="Highlight") +def print_callback(data, buffer, date, tags, displayed, highlight, prefix, message): + buffer_name = weechat.buffer_get_string(buffer, "name") + if highlight == "1": + postIm(message, label="weechat", title="Highlight", buffer_name=buffer_name, prefix=prefix) + elif "notify_private" in tags.split(','): + postIm(message, label="weechat", title="Private Message", buffer_name=buffer_name, prefix=prefix) return weechat.WEECHAT_RC_OK -weechat.hook_signal("weechat_highlight", "signal_callback", "") -weechat.hook_signal("weechat_pv", "signal_callback", "") +weechat.hook_print("", "", "", 1, "print_callback", ""); diff -Nru weechat-scripts-20130123/python/jabber.py weechat-scripts-20131007/python/jabber.py --- weechat-scripts-20130123/python/jabber.py 2013-01-23 19:00:12.000000000 +0000 +++ weechat-scripts-20131007/python/jabber.py 2013-10-07 12:14:44.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (C) 2009-2012 Sebastien Helleu +# Copyright (C) 2009-2013 Sebastien Helleu # Copyright (C) 2010 xt # Copyright (C) 2010 Aleksey V. Zapparov # @@ -26,6 +26,14 @@ # Happy chat, enjoy :) # # History: +# 2013-09-30, Nils Görs : +# version 1.6: add support of /secure for passwords and jid +# : fix stdout/stderr when no JID was set +# 2013-05-14, Billiam : +# version 1.5: fix unicode encoding error in /jabber buddies +# 2013-05-03, Sebastien Helleu : +# version 1.4: add tags in user messages: notify_xxx, no_highlight, +# nick_xxx, prefix_nick_xxx, log1 # 2012-05-12, Sebastian Rydberg : # version 1.3: Added support for fetching names from roster # 2012-04-11, Sebastien Helleu : @@ -79,7 +87,7 @@ SCRIPT_NAME = "jabber" SCRIPT_AUTHOR = "Sebastien Helleu " -SCRIPT_VERSION = "1.3" +SCRIPT_VERSION = "1.6" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Jabber/XMPP protocol for WeeChat" SCRIPT_COMMAND = SCRIPT_NAME @@ -458,7 +466,16 @@ weechat.buffer_set(self.buffer, "nicklist_display_groups", "1") weechat.buffer_set(self.buffer, "display", "auto") self.disconnect() - self.buddy = Buddy(jid=self.option_string("jid"), server=self) + + if not eval_expression(self.option_string("jid")): + weechat.prnt(self.buffer, "%sjabber: JID must contain at least domain name" + % weechat.prefix("error")) + self.ping_up = False + self.client = None + return self.is_connected() + + self.buddy = Buddy(jid=eval_expression(self.option_string("jid")), server=self) + server = self.option_string("server") port = self.option_integer("port") self.client = xmpp.Client(server=self.buddy.domain, debug=[]) @@ -485,9 +502,11 @@ res = self.buddy.resource if not res: res = "WeeChat" + auth = self.client.auth(self.buddy.username, - self.option_string("password"), + eval_expression(self.option_string("password")), res) + if auth: weechat.prnt(self.buffer, "jabber: authentication ok (using %s)" % auth) @@ -634,22 +653,25 @@ self.disconnect() if weechat.config_boolean(self.options['autoreconnect']): autoreconnect_delay = 30 - weechat.command('', '/wait %s /%s connect %s' %(\ - autoreconnect_delay, SCRIPT_COMMAND, self.name)) + weechat.command('', '/wait %s /%s connect %s' % + (autoreconnect_delay, SCRIPT_COMMAND, self.name)) def recv_message(self, buddy, message): """ Receive a message from buddy. """ - weechat.prnt_date_tags(self.buffer, 0, "notify_private", + weechat.prnt_date_tags(self.buffer, 0, + "notify_private,nick_%s,prefix_nick_%s,log1" % + (buddy.alias, + weechat.config_string(weechat.config_get("weechat.color.chat_nick_other"))), "%s%s\t%s" % (weechat.color("chat_nick_other"), buddy.alias, message)) def print_status(self, nickname, status): - ''' Print a status in server window and in chat ''' - weechat.prnt_date_tags(self.buffer, 0, 'no_highlight', "%s%s has status %s" % (\ - weechat.prefix("action"), - nickname, - status)) + """ Print a status in server window and in chat. """ + weechat.prnt_date_tags(self.buffer, 0, "no_highlight", "%s%s has status %s" % + (weechat.prefix("action"), + nickname, + status)) for chat in self.chats: if nickname in chat.buddy.alias: chat.print_status(status) @@ -697,9 +719,13 @@ sender = self.buddy.alias except: sender = self.jid - weechat.prnt(self.buffer, "%s%s\t%s" % (weechat.color("chat_nick_self"), - sender, - message.strip())) + weechat.prnt_date_tags(self.buffer, 0, + "notify_none,no_highlight,nick_%s,prefix_nick_%s,log1" % + (sender, + weechat.config_string(weechat.config_get("weechat.color.chat_nick_self"))), + "%s%s\t%s" % (weechat.color("chat_nick_self"), + sender, + message.strip())) def set_away(self, message): """ Set/unset away on server. @@ -738,19 +764,20 @@ len_max = { 'alias': 5, 'jid': 5 } lines = [] - for buddy in sorted(self.buddies, key=lambda x: str(x.jid)): + for buddy in sorted(self.buddies, key=lambda x: x.jid.getStripped().encode('utf-8')): alias = '' if buddy.alias != buddy.bare_jid: alias = buddy.alias + buddy_jid_string = buddy.jid.getStripped().encode('utf-8') lines.append( { - 'jid': str(buddy.jid), + 'jid': buddy_jid_string, 'alias': alias, 'status': buddy.away_string(), }) if len(alias) > len_max['alias']: len_max['alias'] = len(alias) - if len(str(buddy.jid)) > len_max['jid']: - len_max['jid'] = len(str(buddy.jid)) + if len(buddy_jid_string) > len_max['jid']: + len_max['jid'] = len(buddy_jid_string) prnt_format = " %s%-" + str(len_max['jid']) + "s %-" + str(len_max['alias']) + "s %s" weechat.prnt(self.buffer, prnt_format % ('', 'JID', 'Alias', 'Status')) for line in lines: @@ -942,6 +969,13 @@ for name, option in self.options.items(): weechat.config_option_free(option) +def eval_expression(option_name): + """ Return a evaluated expression """ + if int(version) >= 0x00040200: + return weechat.string_eval_expression(option_name,{},{},{}) + else: + return option_name + def jabber_search_server_by_name(name): """ Search a server by name. """ global jabber_servers @@ -966,7 +1000,7 @@ return context def jabber_search_context_by_name(server_name): - ''' Search for buffer given name of server ''' + """Search for buffer given name of server. """ bufname = "%s.server.%s" % (SCRIPT_NAME, server_name) return jabber_search_context(weechat.buffer_search("python", bufname)) @@ -1005,7 +1039,10 @@ if buddy.alias != self.buffer_title: self.buffer_title = buddy.alias weechat.buffer_set(self.buffer, "title", "%s" % self.buffer_title) - weechat.prnt_date_tags(self.buffer, 0, "notify_private", + weechat.prnt_date_tags(self.buffer, 0, + "notify_private,nick_%s,prefix_nick_%s,log1" % + (buddy.alias, + weechat.config_string(weechat.config_get("weechat.color.chat_nick_other"))), "%s%s\t%s" % (weechat.color("chat_nick_other"), buddy.alias, message)) @@ -1017,15 +1054,19 @@ % weechat.prefix("error")) return self.server.send_message(self.buddy, message) - weechat.prnt(self.buffer, "%s%s\t%s" % (weechat.color("chat_nick_self"), - self.server.buddy.alias, - message)) + weechat.prnt_date_tags(self.buffer, 0, + "notify_none,no_highlight,nick_%s,prefix_nick_%s,log1" % + (self.server.buddy.alias, + weechat.config_string(weechat.config_get("weechat.color.chat_nick_self"))), + "%s%s\t%s" % (weechat.color("chat_nick_self"), + self.server.buddy.alias, + message)) def print_status(self, status): - ''' Print a status message in chat ''' - weechat.prnt(self.buffer, "%s%s has status %s" % (\ - weechat.prefix("action"), - self.buddy.alias, - status)) + """ Print a status message in chat. """ + weechat.prnt(self.buffer, "%s%s has status %s" % + (weechat.prefix("action"), + self.buddy.alias, + status)) def close_buffer(self): """ Close chat buffer. """ @@ -1247,8 +1288,9 @@ connected = "" if server.sock >= 0: connected = "(connected)" + weechat.prnt("", " %s - %s %s %s" % (server.name, - server.option_string("jid"), conn_server, connected)) + eval_expression(server.option_string("jid")), conn_server, connected)) for chat in server.chats: weechat.prnt("", " chat with %s" % (chat.buddy)) else: @@ -1567,10 +1609,6 @@ weechat.prnt("", prnt_format % ('Alias', 'JID')) for alias, jid in sorted(jabber_jid_aliases.items()): weechat.prnt("", prnt_format % (alias, jid)) - #FIXME \\\ - import sys - weechat.prnt('', "jabber: sys.version: %s" % (sys.version)) # FIXME - #FIXME /// return def parse(self): @@ -1666,6 +1704,8 @@ if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "jabber_unload_script", ""): + + version = weechat.info_get("version_number", "") or 0 jabber_hook_commands_and_completions() jabber_config_init() jabber_config_read() diff -Nru weechat-scripts-20130123/python/keepnick.py weechat-scripts-20131007/python/keepnick.py --- weechat-scripts-20130123/python/keepnick.py 2013-01-23 19:00:17.000000000 +0000 +++ weechat-scripts-20131007/python/keepnick.py 2013-10-07 12:14:48.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2012 by nils_2 +# Copyright (c) 2012-2013 by nils_2 # Copyright (c) 2006 by EgS # # script to keep your nick and recover it in case it's occupied @@ -18,6 +18,18 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-09-17: nils_2 (freenode.#weechat) +# 1.1 : format of weechat_string_eval_expression() changed +# +# 2013-07-29: nils_2 (freenode.#weechat) +# 1.0 : support of /secure for passwords +# +# 2013-01-29: nils_2 (freenode.#weechat) +# 0.9 : script optimized +# +# 2013-01-27: nils_2 (freenode.#weechat) +# 0.8 : make script compatible with Python 3.x +# # 2012-10-05: nils_2, (freenode.#weechat) # 0.7 : add options "plugins.var.python.keepnick.nickserv", "plugins.var.python.keepnick..password" # : changed default "delay" value from 60 to 600 seconds. @@ -62,14 +74,14 @@ except Exception: - print "This script is to be loaded as PythonScript in WeeChat" - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() # -------------------------------[ Constants ]------------------------------------- SCRIPT_NAME = "keepnick" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.7" +SCRIPT_VERSION = "1.1" SCRIPT_LICENCE = "GPL3" SCRIPT_DESC = "keep your nick and recover it in case it's occupied" @@ -79,7 +91,7 @@ 'timeout' : ('60','timeout (in seconds) to wait for an answer from server.'), 'serverlist' : ('','comma separated list of servers to look at. Try to register a nickname on server (see: /msg NickServ help).'), 'text' : ('Nickstealer left Network: %s!','text that will be displayed if your nick will not be occupied anymore. (\"%s\" is a placeholder for the servername)'), - 'nickserv' : ('/msg -server $server NICKSERV IDENTIFY $passwd','use this command to IDENTIFY you on server (following placeholder will be used: \"$server\" for server; \"$passwd\" for password. You have to create a option \"plugins.var.python.%s..password\" to store your nick password. Use SASL authentification, if possible.' % SCRIPT_NAME), + 'nickserv' : ('/msg -server $server NICKSERV IDENTIFY $passwd','Use SASL authentification, if possible. This command will be used to IDENTIFY you on server (following placeholder can be used: \"$server\" for servername; \"$passwd\" for password. The password will be stored in a separate option for every single server: \"plugins.var.python.%s..password\"). Using the "/secure" function, you\'ll have to add a format described in "/help secure" to password option (eg: ${sec.data.keepnick_freenode_password})' % SCRIPT_NAME), 'command' : ('/nick %s','This command will be used to rename your nick (\"%s\" will be filled with your nickname for specific server)'), } HOOK = { 'timer': '', 'redirect': '' } @@ -97,57 +109,61 @@ if hashtable['output'] == '': return weechat.WEECHAT_RC_OK - nothing, message, nicks = hashtable['output'].split(':') - nicks = [nick.lower() for nick in nicks.split()] - for nick in servernicks(hashtable['server']): + # ISON_nicks contains nicks that are already online on server (separated with space) + message,ISON_nicks = hashtable['output'].split(':')[1:] + ISON_nicks = [nick.lower() for nick in ISON_nicks.split()] + + for nick in server_nicks(hashtable['server']): mynick = weechat.info_get('irc_nick',hashtable['server']) if nick.lower() == mynick.lower(): return weechat.WEECHAT_RC_OK - elif nick.lower() not in nicks: - password = weechat.config_get_plugin('%s.password' % hashtable['server']) # get password for given server - grabnick(hashtable['server'], nick) # get back your nick - if (password) != '': - if OPTIONS['nickserv'] == '': - return weechat.WEECHAT_RC_OK + elif nick.lower() not in ISON_nicks and nick != '': + if int(version) >= 0x00040200: + password = weechat.string_eval_expression(weechat.config_get_plugin('%s.password' % hashtable['server']),{},{},{}) + else: + password = weechat.config_get_plugin('%s.password' % hashtable['server']) # get password for given server + + grabnick(hashtable['server'], nick) # get your nick back + if password != '' and OPTIONS['nickserv'] != '': t = Template(OPTIONS['nickserv']) run_msg = t.safe_substitute(server=hashtable['server'], passwd=password) weechat.command('',run_msg) - return weechat.WEECHAT_RC_OK + return weechat.WEECHAT_RC_OK - if 0 in [nick.lower() in [mynick.lower() for mynick in servernicks(hashtable['server'])] for nick in nicks]: +# if 0 in [nick.lower() in [mynick.lower() for mynick in server_nicks(hashtable['server'])] for nick in nicks]: # if any nick which is return by ison is not on our checklist we're not the caller - return weechat.WEECHAT_RC_OK - else: +# return weechat.WEECHAT_RC_OK +# else: # seems like we're the caller -> ignore the output - return weechat.WEECHAT_RC_OK +# return weechat.WEECHAT_RC_OK # ================================[ functions ]=============================== -def servernicks(servername): +# nicks used on server +def server_nicks(servername): infolist = weechat.infolist_get('irc_server','',servername) weechat.infolist_next(infolist) nicks = weechat.infolist_string(infolist, 'nicks') weechat.infolist_free(infolist) - servernicks = nicks.split(',') - return servernicks + return nicks.split(',') -def checknicks(data, remaining_calls): +def check_nicks(data, remaining_calls): serverlist = OPTIONS['serverlist'].split(',') infolist = weechat.infolist_get('irc_server','','') while weechat.infolist_next(infolist): servername = weechat.infolist_string(infolist, 'name') - bufpointer = weechat.infolist_pointer(infolist,'buffer') + ptr_buffer = weechat.infolist_pointer(infolist,'buffer') nick = weechat.infolist_string(infolist, 'nick') ssl_connected = weechat.infolist_integer(infolist,'ssl_connected') is_connected = weechat.infolist_integer(infolist,'is_connected') if servername in serverlist: if nick and ssl_connected + is_connected: - ison(bufpointer,servername,nick,servernicks(servername)) + ison(ptr_buffer,servername,nick,server_nicks(servername)) weechat.infolist_free(infolist) return weechat.WEECHAT_RC_OK def grabnick(servername, nick): - if nick: + if nick and servername: weechat.prnt(weechat.current_buffer(),OPTIONS['text'] % servername) weechat.command(weechat.buffer_search('irc','%s.%s' % ('server',servername)), OPTIONS['command'] % nick) @@ -160,7 +176,7 @@ if not OPTIONS['delay'] or not OPTIONS['timeout']: return - HOOK['timer'] = weechat.hook_timer(int(OPTIONS['delay']) * 1000, 0, 0, 'checknicks', '') + HOOK['timer'] = weechat.hook_timer(int(OPTIONS['delay']) * 1000, 0, 0, 'check_nicks', '') HOOK['redirect'] = weechat.hook_hsignal('irc_redirection_%s_ison' % SCRIPT_NAME, 'redirect_isonhandler', '' ) if HOOK['timer'] == 0: @@ -181,10 +197,10 @@ # ================================[ weechat options and description ]=============================== def init_options(): global HOOK,OPTIONS - for option,value in OPTIONS.items(): + for option,value in list(OPTIONS.items()): + weechat.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) if not weechat.config_is_set_plugin(option): weechat.config_set_plugin(option, value[0]) - weechat.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) OPTIONS[option] = value[0] else: OPTIONS[option] = weechat.config_get_plugin(option) @@ -208,7 +224,7 @@ version = weechat.info_get("version_number", "") or 0 if int(version) >= 0x00030400: - if OPTIONS['delay'] > 0 and OPTIONS['timeout'] > 0: + if int(OPTIONS['delay'][0]) > 0 and int(OPTIONS['timeout'][0]) > 0: init_options() install_hooks() weechat.hook_config( 'plugins.var.python.' + SCRIPT_NAME + '.*', 'toggle_refresh', '' ) diff -Nru weechat-scripts-20130123/python/listbuffer.py weechat-scripts-20131007/python/listbuffer.py --- weechat-scripts-20130123/python/listbuffer.py 2013-01-23 19:00:15.000000000 +0000 +++ weechat-scripts-20131007/python/listbuffer.py 2013-10-07 12:14:46.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# ListBuffer, version 0.7.1 for WeeChat version 0.3 +# ListBuffer, version 0.8.1 for WeeChat version 0.3 # Latest development version: https://github.com/FiXato/listbuffer # # Show /list results in a common buffer and interact with them. @@ -55,6 +55,19 @@ # * version 0.7.1: Forgetful bugfix # * Made sure lb_curline global variable is defined # +### 2013-03-19: FiXato: +# +# * version 0.8: Sorted out the sorting +# * Added automatically updating options for sorting: +# * plugins.var.python.listbuffer.sort_inverted +# * plugins.var.python.listbuffer.sort_order +# * version 0.8.1: Pad it baby! +# * Channel modes are equally padded even when there are no channel modes. +# * Added padding options: +# * plugins.var.python.listbuffer.modes_min_width +# * plugins.var.python.listbuffer.channel_min_width +# * plugins.var.python.listbuffer.users_min_width +# ## Acknowledgements: # * Dmitry "troydm" Geurkov, for providing the inverse-sorting patch to the project. # * Sebastien "Flashcode" Helleu, for developing the kick-ass IRC client WeeChat @@ -68,15 +81,12 @@ # copied and ported to Python. # * Khaled Mardam-Bey, for making me yearn for similar /list support in # WeeChat as mIRC already offered. :P +# * mave_, for pointing out that sort orders weren't remembered. # ## TODO: # - Auto-scroll selected line upon window scroll. # - Add option to hide already joined channels. # - Improve sorting methods -# - Add default sorting option -# - Add channel padding length option -# - Add usercount padding length option -# - Add modes padding length option # - Add auto-join support # - Detect if channel is already in auto-join # - Allow automatically switching to the listbuffer @@ -87,9 +97,9 @@ # - Allow selecting multiple channels # - Add optional command redirection. # -## Copyright (c) 2011,2012 Filip H.F. "FiXato" Slagter, +## Copyright (c) 2011,2012,2013 Filip H.F. "FiXato" Slagter, # -# http://google.com/profiles/FiXato +# http://profile.fixato.org # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the @@ -112,7 +122,7 @@ # SCRIPT_NAME = "listbuffer" SCRIPT_AUTHOR = "Filip H.F. 'FiXato' Slagter " -SCRIPT_VERSION = "0.7.1" +SCRIPT_VERSION = "0.8.1" SCRIPT_LICENSE = "MIT" SCRIPT_DESC = "A common buffer for /list output." SCRIPT_COMMAND = "listbuffer" @@ -129,6 +139,11 @@ lb_settings = ( ("autofocus", "on", "Focus the listbuffer in the current window if it isn't already displayed by a window."), + ("sort_order", "users", "Last used sort order for the channel list."), + ("sort_inverted", "on", "Invert the sort order for the channel list."), + ("modes_min_width", "8", "The minimum width used for modes in the channel list. If a channel has less modes than this amount, the column will be padded with spaces."), + ("channel_min_width", "25", "The minimum width used for the channel name in the channel list. If a channelname is shorter than this amount, the column will be padded with spaces."), + ("users_min_width", "8", "The minimum width used for the usercount in the channel list. If the usercount has less digits than this amount, the column will be padded with spaces."), ) lb_buffer = None lb_curline = 0 @@ -138,10 +153,10 @@ lb_current_sort = None lb_sort_inverted = False lb_sort_options = ( - 'users', 'channel', - 'topic', + 'users', 'modes', + 'topic', ) # server numeric Nick Chan Users Modes Topic @@ -154,13 +169,7 @@ if not lb_buffer: lb_buffer = weechat.buffer_new("listbuffer", "lb_input_cb", \ "", "lb_close_cb", "") - weechat.buffer_set(lb_buffer, "title", lb_line_format({ - 'channel': 'Channel name', - 'users': 'Users', - 'modes': 'Modes', - 'topic': 'Topic', - 'nomodes': None, - })) + lb_set_buffer_title() # Sets notify to 0 as this buffer does not need to be in hotlist. weechat.buffer_set(lb_buffer, "notify", "0") weechat.buffer_set(lb_buffer, "nicklist", "0") @@ -180,6 +189,17 @@ if not weechat.window_search_with_buffer(lb_buffer): weechat.command("", "/buffer " + weechat.buffer_get_string(lb_buffer,"name")) +def lb_set_buffer_title(): + global lb_buffer, lb_current_sort + ascdesc = '(v)' if lb_sort_inverted else '(^)' + weechat.buffer_set(lb_buffer, "title", lb_line_format({ + 'channel': 'Channel name%s' % (ascdesc if lb_current_sort == 'channel' else ''), + 'users': 'Users%s' % (ascdesc if lb_current_sort == 'users' else ''), + 'modes': 'Modes%s' % (ascdesc if lb_current_sort == 'modes' else ''), + 'topic': 'Topic%s' % (ascdesc if lb_current_sort == 'topic' else ''), + 'nomodes': None, + })) + def lb_list_start(data, signal, message): lb_initialise_list @@ -223,6 +243,8 @@ lb_initialise_list(signal) lb_list_started = False + if lb_current_sort: + lb_sort() lb_refresh() return weechat.WEECHAT_RC_OK @@ -262,9 +284,15 @@ str = "" if (curr): str += weechat.color("yellow,red") - str += "%s%25s %7s " % (weechat.color("bold"), list_data['channel'], "(%s)" % list_data['users']) + channel_text = list_data['channel'].ljust(int(weechat.config_get_plugin('channel_min_width'))) + users_text = "(%s)" % list_data['users'] + padded_users_text = users_text.rjust(int(weechat.config_get_plugin('users_min_width')) + 2) + str += "%s%s %s " % (weechat.color("bold"), channel_text, padded_users_text) if not list_data['nomodes']: - str += "%10s: " % ("[%s]" % list_data['modes']) + modes = "[%s]" % list_data['modes'] + else: + modes = "[]" + str += "%s: " % modes.rjust(int(weechat.config_get_plugin('modes_min_width')) + 2) str += "%s" % list_data['topic'] return str @@ -338,9 +366,19 @@ if len(lb_sort_options) <= new_index: new_index = 0 - lb_current_sort = lb_sort_options[new_index] + lb_set_current_sort_order(lb_sort_options[new_index]) lb_sort() +def lb_set_current_sort_order(value): + global lb_current_sort + lb_current_sort = value + weechat.config_set_plugin('sort_order', lb_current_sort) + +def lb_set_invert_sort_order(value): + global lb_sort_inverted + lb_sort_inverted = value + weechat.config_set_plugin('sort_inverted', ('on' if lb_sort_inverted else 'off')) + def lb_sort_previous(): global lb_current_sort, lb_sort_options if lb_current_sort: @@ -351,25 +389,26 @@ if new_index < 0: new_index = len(lb_sort_options) - 1 - lb_current_sort = lb_sort_options[new_index] + lb_set_current_sort_order(lb_sort_options[new_index]) lb_sort() def lb_sort(sort_key=None): global lb_channels, lb_current_sort, lb_sort_inverted if sort_key: - lb_current_sort = sort_key + lb_set_current_sort_order(sort_key) if lb_current_sort == 'users': lb_channels = sorted(lb_channels, key=lambda chan_data: int(chan_data[lb_current_sort])) else: lb_channels = sorted(lb_channels, key=lambda chan_data: chan_data[lb_current_sort]) if lb_sort_inverted: lb_channels.reverse() + lb_set_buffer_title() lb_refresh() def lb_sort_invert(): global lb_current_sort, lb_sort_inverted if lb_current_sort: - lb_sort_inverted = not lb_sort_inverted + lb_set_invert_sort_order(not lb_sort_inverted) lb_sort() def lb_close_cb(*kwargs): @@ -407,10 +446,16 @@ if int(version) >= 0x00030500: weechat.config_set_desc_plugin(option, description) +def lb_reset_stored_sort_order(): + global lb_current_sort, lb_sort_inverted + lb_current_sort = weechat.config_get_plugin('sort_order') + lb_sort_inverted = (True if weechat.config_get_plugin('sort_inverted') == 'on' else False) + if __name__ == "__main__" and import_ok: if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "lb_close_cb", ""): lb_set_default_settings() + lb_reset_stored_sort_order() lb_buffer = weechat.buffer_search("python", "listbuffer") weechat.hook_signal("*,irc_in_321", "lb_list_start", "") diff -Nru weechat-scripts-20130123/python/lnotify.py weechat-scripts-20131007/python/lnotify.py --- weechat-scripts-20130123/python/lnotify.py 2013-01-23 19:00:12.000000000 +0000 +++ weechat-scripts-20131007/python/lnotify.py 2013-10-07 12:14:44.000000000 +0000 @@ -1,24 +1,37 @@ # Copyright (C) 2010 Kevin Morris # lnotify made to use for libnotify notifications -# must have /usr/bin/send-notify # This script was adapted from 'notify' # Hope you guys like it :O # # 0.1.2 # added option to display weechat's icon by tomboy64 +# +# 0.1.3 +# changed the way that icon to WeeChat notification is specified. +# (No absolute path is needed) +# /usr/bin/notify-send isn't needed anymore. +# (pynotify is handling notifications now) +# changed the way that lnotify works. When using gnome 3, every new +# notification was creating a new notification instance. The way that +# it is now, all WeeChat notifications are in a group (that have the +# WeeChat icon and have WeeChat name). +# Got report that it has better look for KDE users too. -import weechat, string, subprocess, os +import weechat, string, pynotify -weechat.register("lnotify", "kevr", "0.1.2", "GPL3", "lnotify - A libnotify script for weechat", "", "") +weechat.register("lnotify", "kevr", "0.1.3", "GPL3", "lnotify - A libnotify script for weechat", "", "") # Set up here, go no further! settings = { "show_highlight" : "on", "show_priv_msg" : "on", - "icon" : "/usr/share/icons/hicolor/32x32/apps/weechat.png" + "show_icon" : "weechat" } # Init everything +if not pynotify.init("WeeChat"): + print "Failed to load lnotify" + for option, default_value in settings.items(): if weechat.config_get_plugin(option) == "": weechat.config_set_plugin(option, default_value) @@ -35,16 +48,18 @@ buffer = (weechat.buffer_get_string(bufferp, "short_name") or weechat.buffer_get_string(bufferp, "name")) if buffer == prefix: - subprocess.call(['/usr/bin/notify-send', 'In Private Message %s: %s' % (prefix, message)],shell=False) + n = pynotify.Notification("WeeChat", "%s said: %s" % (prefix, + message),weechat.config_get_plugin('show_icon')) + if not n.show(): + print "Failed to send notification" elif (ishilight == "1" and weechat.config_get_plugin('show_highlight') == "on"): buffer = (weechat.buffer_get_string(bufferp, "short_name") or weechat.buffer_get_string(bufferp, "name")) - if os.path.isfile( weechat.config_get_plugin('icon') ): - subprocess.call(['/usr/bin/notify-send', '-i', weechat.config_get_plugin('icon'), 'In %s %s: %s' % (buffer, prefix, message)],shell=False) - else: - subprocess.call(['/usr/bin/notify-send', 'In %s %s: %s' % (buffer, prefix, message)],shell=False) + n = pynotify.Notification("WeeChat", "In %s, %s said: %s" % (buffer, + prefix, message),weechat.config_get_plugin('show_icon')) + if not n.show(): + print "Failed to send notification" return weechat.WEECHAT_RC_OK - diff -Nru weechat-scripts-20130123/python/opall.py weechat-scripts-20131007/python/opall.py --- weechat-scripts-20130123/python/opall.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/opall.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,72 @@ +# -*- coding: utf-8 -*- +# +# Copyright (c) 2013, blarz +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +SCRIPT_NAME = 'opall' +SCRIPT_AUTHOR = 'blarz' +SCRIPT_VERSION = '0.1' +SCRIPT_LICENSE = 'ISC' +SCRIPT_DESC = 'Give op to everybody, like /op -Yes * in irssi' + +try: + import weechat + import_ok = True +except ImportError: + print('This script must be run under WeeChat.') + print('Get WeeChat now at: http://www.weechat.org/') + import_ok = False + +def withoutOp(server, channel): + L = [] + + infolist = weechat.infolist_get('irc_nick', '', '%s,%s' %(server, channel)) + while weechat.infolist_next(infolist): + if not '@' in weechat.infolist_string(infolist, 'prefix'): + L.append(weechat.infolist_string(infolist, 'name')) + weechat.infolist_free(infolist) + + return L + +def opall(data, buffer, args): + channel = weechat.buffer_get_string(buffer, 'localvar_channel') + server = weechat.buffer_get_string(buffer, 'localvar_server') + + if not weechat.info_get('irc_is_channel', channel): + weechat.prnt(buffer, '%sopall: Not an IRC channel' % weechat.prefix('error')) + return weechat.WEECHAT_RC_OK + + toOp = withoutOp(server, channel) + if len(toOp) == 0: + return weechat.WEECHAT_RC_OK + + # how many people can we op at once + modes = int(weechat.info_get('irc_server_isupport_value', '%s,MODES' % server)) or 0 + if modes == 0: + weechat.prnt(buffer, '%sopall: failed to determine MODES' % weechat.prefix('error')) + return weechat.WEECHAT_RC_ERROR + + frm = 0 + to = modes + while len(toOp) > frm: + weechat.command(buffer, '/OP %s' % ' '.join(toOp[frm:to])) + frm = to + to += modes + + return weechat.WEECHAT_RC_OK + +if __name__ == '__main__' and import_ok: + weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', '') + + weechat.hook_command(SCRIPT_NAME, SCRIPT_DESC, '', '', '', 'opall', ''); diff -Nru weechat-scripts-20130123/python/prism.py weechat-scripts-20131007/python/prism.py --- weechat-scripts-20130123/python/prism.py 2013-01-23 19:00:11.000000000 +0000 +++ weechat-scripts-20131007/python/prism.py 2013-10-07 12:14:43.000000000 +0000 @@ -8,6 +8,17 @@ # TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION # # 0. You just DO WHAT THE FUCK YOU WANT TO. +# 2013-07-19, Sebastien Helleu +# v0.2.6: use buffer received in command callback instead of current buffer +# 2013-05-04, Rylai +# v0.2.5: add -e switch for the option to destroy the eyes of all +# who have the misfortune of seeing your text +# 2013-04-26, Biohazard +# v0.2.4: add support for using the command through keybindings +# 2013-03-12, R1cochet +# v0.2.3: add -b switch for backwards/reverse text +# 2013-01-29, SuperT1R: +# v0.2.2: add -m switch to append /me to the beginning of the output import weechat as w @@ -17,7 +28,7 @@ SCRIPT_NAME = "prism" SCRIPT_AUTHOR = "Alex Barrett " -SCRIPT_VERSION = "0.2.1" +SCRIPT_VERSION = "0.2.6" SCRIPT_LICENSE = "WTFPL" SCRIPT_DESC = "Taste the rainbow." @@ -42,49 +53,76 @@ SCRIPT_LICENSE, SCRIPT_DESC, "", ""): w.hook_command("prism", SCRIPT_DESC, - "[-rw] text", + "[-rwmbe] text", " -r: randomizes the order of the color sequence\n" " -w: color entire words instead of individual characters\n" + " -m: append /me to beginning of output\n" + " -b: backwards text (entire string is reversed)\n" + " -e: eye-destroying colors (randomized background colors)\n" " text: text to be colored", - "", "prism_cmd_cb", "") - + "-r|-w|-m|-b|-e", "prism_cmd_cb", "") +def find_another_color(colorCode): + otherColor = (unicode(colors[random.randint(1, color_count - 1) % color_count]).rjust(2, "0")) + while (otherColor == colorCode): + otherColor = (unicode(colors[random.randint(1, color_count - 1) % color_count]).rjust(2, "0")) + return otherColor def prism_cmd_cb(data, buffer, args): global color_index input = args.decode("UTF-8") + input_method = "command" + + if not input: + input = w.buffer_get_string(buffer, "input") + input = input.decode("UTF-8") + input_method = "keybinding" # select a tokenizer and increment mode regex = regex_chars inc = 1 - - m = re.match('-[rw]* ', input) - if m: + mepfx = 0 + bs = 0 + m = re.match('-[rwmbe]* ', input) + if m and input_method == "command": opts = m.group(0) input = input[len(opts):] if 'w' in opts: regex = regex_words if 'r' in opts: inc = 0 + if 'm' in opts: + mepfx = 1 + if 'b' in opts: + input = input[::-1] + if 'e' in opts: + bs = 1 output = u"" tokens = re.findall(regex, input) for token in tokens: # prefix each token with a color code color_code = unicode(colors[color_index % color_count]).rjust(2, "0") - output += u"\x03" + color_code + token + if bs == 1: + output += u'\x03' + color_code + ',' + find_another_color(color_code) + token + else: + output += u"\x03" + color_code + token # select the next color or another color at # random depending on the options specified if inc == 0: color_index += random.randint(1, color_count - 1) else: - color_index += inc + color_index += inc # output starting with a / will be executed as a # command unless we escape it with a preceding / if len(output) > 0 and output[0] == "/": output = "/" + output - - w.command(w.current_buffer(), output.encode("UTF-8")) + if mepfx == 1: + output = "/me " + output + if input_method == "keybinding": + w.buffer_set(buffer, "input", output.encode("UTF-8")) + else: + w.command(buffer, output.encode("UTF-8")) return w.WEECHAT_RC_OK diff -Nru weechat-scripts-20130123/python/prowl_notify.py weechat-scripts-20131007/python/prowl_notify.py --- weechat-scripts-20130123/python/prowl_notify.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/prowl_notify.py 2013-10-07 12:14:49.000000000 +0000 @@ -0,0 +1,77 @@ +# Author: kidchunks +# Homepage: http://github.com/kidchunks/weechat-prowl-notify +# Version: 2.0 +# +# prowl_notify requires Prowl on your iPod Touch, iPhone or iPad. +# See more at http://www.prowlapp.com +# +# Requires Weechat 0.3.7 or Greater +# Released under the GNU GPL v3 +# +# Prowl Limitations +# IP addresses are limited to 1000 API calls per hour which begins from the start of the first call. Create a new api key just for this script. +# See more at http://www.prowlapp.com/api.php +# +# prowl_away_notify is derived from notifo http://www.weechat.org/files/scripts/notifo.py +# Original Author: ochameau + + +## settings +api_key = '' # API key from Prowl +force_enabled = 'off' # enables notifications even when not away "on//off" +flood_protection = 'on' # helps prevent flooding "on//off" +flood_interval = '30' # time in seconds until reseting. + +## libraries +import weechat, time + +## registration +weechat.register("prowl_notify", "kidchunks", "2.0", "GPL3", "Push notifications to iPod Touch, iPhone or iPad with Prowl", "", "") + +## variables +oldTime = 0; + +## functions +def flood_check(): + global oldTime + currentTime = int(time.time()) + elaspedTime = currentTime - oldTime + if flood_interval >= elaspedTime: + return False + else: + oldTime = currentTime + return True + +def postProwl(label, title, message): + if api_key != "": + opt_dict = "apikey=" + api_key + "&application=" + label + "&event=" + title + "&description=" + message + weechat.hook_process_hashtable("url:https://api.prowlapp.com/publicapi/add?", + { "postfields": opt_dict }, + 30 * 1000, "", "") + else: + weechat.prnt("", "API Key is missing!") + return weechat.WEECHAT_RC_OK + +def hook_callback(data, bufferp, uber_empty, tagsn, isdisplayed, + ishighlight, prefix, message): + if (bufferp == weechat.current_buffer()): + pass + + # highlight + elif ishighlight == "1" and (weechat.buffer_get_string(bufferp, 'localvar_away') or force_enabled == 'on'): + if flood_check() or oldTime == 0: + buffer = (weechat.buffer_get_string(bufferp, "short_name") or weechat.buffer_get_string(bufferp, "name")) + if prefix == buffer: # treat as pm if user mentions your nick in a pm + postProwl("WeeChat", "Private Message from " + prefix, message) + elif prefix != buffer: # otherwise, treat as highlight + postProwl("WeeChat", prefix + " mentioned you on " + buffer, message) + + # privmsg + elif weechat.buffer_get_string(bufferp, "localvar_type") == "private" and (weechat.buffer_get_string(bufferp, 'localvar_away') or force_enabled == 'on'): + if flood_check() or oldTime == 0: + postProwl("WeeChat", "Private Message from " + prefix, message) + + return weechat.WEECHAT_RC_OK + +weechat.hook_print("", "notify_message", "", 1, "hook_callback", "") +weechat.hook_print("", "notify_private", "", 1, "hook_callback", "") diff -Nru weechat-scripts-20130123/python/purgelogs.py weechat-scripts-20131007/python/purgelogs.py --- weechat-scripts-20130123/python/purgelogs.py 2013-01-23 19:00:13.000000000 +0000 +++ weechat-scripts-20131007/python/purgelogs.py 2013-10-07 12:14:45.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2011 by nils_2 +# Copyright (c) 2011-2013 by nils_2 # # 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 @@ -29,11 +29,15 @@ # /set plugins.var.python.purgelogs.blacklist "#weechat,#weechat-fr,nils_2" # # History: -# 2011-09-17: nils_2 (freenode.#weechat) +# 2013-01-25: nils_2, (freenode.#weechat) +# 0.4 : make script compatible with Python 3.x +# 2011-09-18: nils_2, (freenode.#weechat) +# 0.3.1 : code optimization +# 2011-09-17: nils_2, (freenode.#weechat) # 0.3 : added: search for log-files smaller than age/size (new functions: age_ls and size_ls) -# 2011-03-11: nils_2 (freenode.#weechat) +# 2011-03-11: nils_2, (freenode.#weechat) # 0.2 : added blacklist option -# 2011-02-18: nils_2 (freenode.#weechat) +# 2011-02-18: nils_2, (freenode.#weechat) # 0.1 : initial release # # Development is currently hosted at @@ -47,13 +51,13 @@ from datetime import date, timedelta except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = "purgelogs" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.3" +SCRIPT_VERSION = "0.4" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "delete weechatlog-files by age or size (YOU ARE USING THIS SCRIPT AT YOUR OWN RISK!)" @@ -104,40 +108,20 @@ if argv[0] in ["", "age_ls"]: i = 0 - dellog_by_date_less(argv[1]) + getdirs(basedir,int(argv[1]),"ls_age") if argv[0] in ["", "size_ls"]: i = 0 - dellog_by_size_less(argv[1]) + getdirs(basedir,int(argv[1]),"ls_size") if argv[0] in ["", "age"]: i = 0 - dellog_by_date(argv[1]) + getdirs(basedir,int(argv[1]),"by_age") if argv[0] in ["", "size"]: i = 0 - dellog_by_size(argv[1]) + getdirs(basedir,int(argv[1]),"by_size") if check_only is False: w.command("","/mute /plugin load logger") return w.WEECHAT_RC_OK -def dellog_by_date(age): - global basedir - getdirs(basedir, int(age), "by_age") - return - -def dellog_by_size(size): - global basedir - getdirs(basedir, int(size), "by_size") - return - -def dellog_by_date_less(age): - global basedir - getdirs(basedir, int(age), "ls_age") - return - -def dellog_by_size_less(size): - global basedir - getdirs(basedir, int(size), "ls_size") - return - def get_path(): """ get logger path """ return w.config_string(w.config_get("logger.file.path")).replace("%h", w.info_get("weechat_dir", "")) @@ -290,7 +274,8 @@ "purgelogs_cb", "") w.hook_config('plugins.var.python.%s.blacklist' %SCRIPT_NAME, 'update_blacklist', '') - for option, default_value in purgelogs_options.iteritems(): + for option, default_value in purgelogs_options.items(): +# for option, default_value in purgelogs_options.iteritems(): if w.config_get_plugin(option) == "": w.config_set_plugin(option, default_value) else: diff -Nru weechat-scripts-20130123/python/pyrnotify.py weechat-scripts-20131007/python/pyrnotify.py --- weechat-scripts-20130123/python/pyrnotify.py 2013-01-23 19:00:17.000000000 +0000 +++ weechat-scripts-20131007/python/pyrnotify.py 2013-10-07 12:14:49.000000000 +0000 @@ -26,6 +26,8 @@ # On the "client" (where the notifications will end up), host is # the remote host where weechat is running: # python2 location/of/pyrnotify.py 4321 & ssh -R 4321:localhost:4321 username@host +# You can have a second argument to specified the time to display the notification +# python2 location/of/pyrnotify.py 4321 2000 & ssh -R 4321:localhost:4321 username@host # Important to remember is that you should probably setup the # connection with public key encryption and use something like # autossh to do this in the background. @@ -40,7 +42,7 @@ # and doesn't require any ports but ssh to be open. # ChangeLog: -# +# # 2012-06-19: Added simple escaping to the title and body strings for # the script to handle trailing backslashes. @@ -57,7 +59,7 @@ SCRIPT_NAME = "pyrnotify" SCRIPT_AUTHOR = "Krister Svanlund " -SCRIPT_VERSION = "0.8" +SCRIPT_VERSION = "0.9" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Send remote notifications over SSH" @@ -110,25 +112,29 @@ ## supposed to be executed in weechat, instead it runs when the script is executed from ## commandline. -def accept_connections(s): +def accept_connections(s, timeout=None): conn, addr = s.accept() try: data = "" d = conn.recv(1024) while d: - data += d + data += d d = conn.recv(1024) finally: conn.close() if data: try: urgency, icon, title, body = shlex.split(data) - subprocess.call(["notify-send", "-u", urgency, "-c", "IRC", "-i", icon, escape(title), escape(body)]) + if timeout: + subprocess.call(["notify-send", "-t", timeout, "-u", urgency, "-c", "IRC", "-i", icon, escape(title), escape(body)]) + else: + subprocess.call(["notify-send", "-u", urgency, "-c", "IRC", "-i", icon, escape(title), escape(body)]) + except ValueError as e: print e except OSError as e: print e - accept_connections(s) + accept_connections(s, timeout) def weechat_client(argv): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) @@ -136,7 +142,7 @@ s.bind(("localhost", int(argv[1] if len(sys.argv) > 1 else 4321))) s.listen(5) try: - accept_connections(s) + accept_connections(s, argv[2] if len(sys.argv) > 2 else None) except KeyboardInterrupt as e: print "Keyboard interrupt" print e diff -Nru weechat-scripts-20130123/python/queryman.py weechat-scripts-20131007/python/queryman.py --- weechat-scripts-20130123/python/queryman.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/queryman.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,122 @@ +# -*- coding: utf-8 -*- +# +# Copyright (c) 2013 by nils_2 +# +# save and restore query buffers after /quit +# +# 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 . +# +# idea by lasers@freenode.#weechat +# +# 2013-07-26: nils_2, (freenode.#weechat) +# 0.1 : initial release +# +# script will create a config file (~./weechat/queryman.txt) +# with format: "servername nickname" (without "") +# +# Development is currently hosted at +# https://github.com/weechatter/weechat-scripts + +try: + import weechat,re,os + +except Exception: + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") + quit() + +SCRIPT_NAME = 'queryman' +SCRIPT_AUTHOR = 'nils_2 ' +SCRIPT_VERSION = '0.1' +SCRIPT_LICENSE = 'GPL' +SCRIPT_DESC = 'save and restore query buffers after /quit' + +query_buffer_list = [] +queryman_filename = 'queryman.txt' + +# ================================[ callback ]=============================== +def quit_signal_cb(data, signal, signal_data): + save_query_buffer_to_file() + return weechat.WEECHAT_RC_OK + +# signal_data contains servername +def irc_server_connected_signal_cb(data, signal, signal_data): + load_query_buffer_irc_server_opened(signal_data) + weechat.prnt("","servername: %s" % signal_data) + return weechat.WEECHAT_RC_OK + +# ================================[ file ]=============================== +def get_filename_with_path(): + global queryman_filename + path = weechat.info_get("weechat_dir", "") + return os.path.join(path,queryman_filename) + +def load_query_buffer_irc_server_opened(server_connected): + global query_buffer_list + + filename = get_filename_with_path() + + try: + f = open(filename, 'rb') + for line in f.xreadlines(): + servername,nick = line.split(' ') + if servername == server_connected: + weechat.command('','/query -server %s %s' % ( servername,nick )) + f.close() + except: + weechat.prnt('','%s%s: Error loading query buffer from "%s"' % (weechat.prefix('error'), SCRIPT_NAME, filename)) + raise + return + +def save_query_buffer_to_file(): + global query_buffer_list + + ptr_infolist_buffer = weechat.infolist_get('buffer', '', '') + + while weechat.infolist_next(ptr_infolist_buffer): + ptr_buffer = weechat.infolist_pointer(ptr_infolist_buffer,'pointer') + + type = weechat.buffer_get_string(ptr_buffer, 'localvar_type') + if type == 'private': + server = weechat.buffer_get_string(ptr_buffer, 'localvar_server') + channel = weechat.buffer_get_string(ptr_buffer, 'localvar_channel') + query_buffer_list.insert(0,"%s %s" % (server,channel)) + + weechat.infolist_free(ptr_infolist_buffer) + + filename = get_filename_with_path() + + if len(query_buffer_list): + try: + f = open(filename, 'w') + i = 0 + while i < len(query_buffer_list): + f.write('%s\n' % query_buffer_list[i]) + i = i + 1 + f.close() + except: + weechat.prnt('','%s%s: Error writing query buffer to "%s"' % (weechat.prefix('error'), SCRIPT_NAME, filename)) + raise + else: # no query buffer(s). remove file + if os.path.isfile(filename): + os.remove(filename) + return + +# ================================[ main ]=============================== +if __name__ == '__main__': + if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', ''): + version = weechat.info_get('version_number', '') or 0 + if int(version) >= 0x00030700: + weechat.hook_signal('quit', 'quit_signal_cb', '') + weechat.hook_signal('irc_server_connected', 'irc_server_connected_signal_cb', '') diff -Nru weechat-scripts-20130123/python/quick_force_color.py weechat-scripts-20131007/python/quick_force_color.py --- weechat-scripts-20130123/python/quick_force_color.py 2013-01-23 19:00:17.000000000 +0000 +++ weechat-scripts-20131007/python/quick_force_color.py 2013-10-07 12:14:48.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2012 by nils_2 +# Copyright (c) 2012-2013 by nils_2 # # quickly add/del/change entry in nick_color_force # @@ -17,6 +17,8 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-01-25: nils_2,(freenode.#weechat) +# 0.4 : make script compatible with Python 3.x # 2012-07-08: obiwahn, (freenode) # 0.3.1 : fix: list nick # : - show nick: color if it is in list @@ -36,16 +38,16 @@ # try: - import weechat,re + import weechat, re except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = "quick_force_color" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.3.1" +SCRIPT_VERSION = "0.4" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "quickly add/del/change entry in nick_color_force" @@ -84,7 +86,8 @@ return weechat.WEECHAT_RC_OK weechat.prnt(buffer,"List of nicks in : nick_color_force") - for nick,color in colored_nicks.items(): +# for nick,color in colored_nicks.items(): + for nick,color in list(colored_nicks.items()): weechat.prnt(buffer,"%s%s: %s" % (weechat.color(color),nick,color)) return weechat.WEECHAT_RC_OK @@ -104,18 +107,21 @@ def save_new_force_nicks(): global colored_nicks - new_nick_color_force = ';'.join([ ':'.join(item) for item in colored_nicks.items()]) +# new_nick_color_force = ';'.join([ ':'.join(item) for item in colored_nicks.items()]) + new_nick_color_force = ';'.join([ ':'.join(item) for item in list(colored_nicks.items())]) config_pnt = weechat.config_get('irc.look.nick_color_force') weechat.config_option_set(config_pnt,new_nick_color_force,1) def nick_colors_completion_cb(data, completion_item, buffer, completion): - for id,color in DEFAULT_COLORS.items(): +# for id,color in DEFAULT_COLORS.items(): + for id,color in list(DEFAULT_COLORS.items()): weechat.hook_completion_list_add(completion, color, 0, weechat.WEECHAT_LIST_POS_SORT) return weechat.WEECHAT_RC_OK def force_nick_colors_completion_cb(data, completion_item, buffer, completion): create_list() - for nick,color in colored_nicks.items(): +# for nick,color in colored_nicks.items(): + for nick,color in list(colored_nicks.items()): weechat.hook_completion_list_add(completion, nick, 0, weechat.WEECHAT_LIST_POS_SORT) return weechat.WEECHAT_RC_OK diff -Nru weechat-scripts-20130123/python/screen_away.py weechat-scripts-20131007/python/screen_away.py --- weechat-scripts-20130123/python/screen_away.py 2013-01-23 19:00:09.000000000 +0000 +++ weechat-scripts-20131007/python/screen_away.py 2013-10-07 12:14:42.000000000 +0000 @@ -24,6 +24,12 @@ # (this script requires WeeChat 0.3.0 or newer) # # History: +# 2013-08-30, Anders Einar Hilden +# version: 0.11: Fix reading of set_away +# 2013-06-16, Renato Botelho +# version 0.10: add option to don't set away, only change nick +# allow multiple commands on attach/dettach +# do not add suffix if nick already have it # 2012-12-29, David Flatz # version 0.9: add option to ignore servers and don't set away status for them # add descriptions to config options @@ -52,7 +58,7 @@ SCRIPT_NAME = "screen_away" SCRIPT_AUTHOR = "xt " -SCRIPT_VERSION = "0.9" +SCRIPT_VERSION = "0.11" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Set away status on screen detach" @@ -60,9 +66,10 @@ 'message': ('Detached from screen', 'Away mesage'), 'interval': ('5', 'How often in seconds to check screen status'), 'away_suffix': ('', 'What to append to your nick when you\'re away.'), - 'command_on_attach': ('', 'Command to execute on attach'), - 'command_on_detach': ('', 'Command to execute on detach'), + 'command_on_attach': ('', 'Commands to execute on attach, separated by semicolon'), + 'command_on_detach': ('', 'Commands to execute on detach, separated by semicolon'), 'ignore': ('', 'Comma-separated list of servers to ignore.'), + 'set_away': ('on', 'Set user as away.'), } TIMER = None @@ -93,9 +100,10 @@ if not w.infolist_integer(infolist, 'is_connected') == 1 or \ w.infolist_string(infolist, 'name') in ignores: continue - if not w.infolist_integer(infolist, 'is_away') or \ - w.infolist_string(infolist, 'away_message') == \ - w.config_get_plugin('message'): + if not w.config_string_to_boolean(w.config_get_plugin('set_away')) or \ + not w.infolist_integer(infolist, 'is_away') or \ + w.infolist_string(infolist, 'away_message') == \ + w.config_get_plugin('message'): buffers.append((w.infolist_pointer(infolist, 'buffer'), w.infolist_string(infolist, 'nick'))) w.infolist_free(infolist) @@ -106,29 +114,32 @@ global AWAY, SOCK + set_away = w.config_string_to_boolean(w.config_get_plugin('set_away')) suffix = w.config_get_plugin('away_suffix') attached = os.access(SOCK, os.X_OK) # X bit indicates attached if attached and AWAY: w.prnt('', '%s: Screen attached. Clearing away status' % SCRIPT_NAME) for server, nick in get_servers(): - w.command(server, "/away") + if set_away: + w.command(server, "/away") if suffix and nick.endswith(suffix): nick = nick[:-len(suffix)] w.command(server, "/nick %s" % nick) AWAY = False - if w.config_get_plugin("command_on_attach"): - w.command("", w.config_get_plugin("command_on_attach")) + for cmd in w.config_get_plugin("command_on_attach").split(";"): + w.command("", cmd) elif not attached and not AWAY: w.prnt('', '%s: Screen detached. Setting away status' % SCRIPT_NAME) for server, nick in get_servers(): - if suffix: + if suffix and not nick.endswith(suffix): w.command(server, "/nick %s%s" % (nick, suffix)); - w.command(server, "/away %s" % w.config_get_plugin('message')); + if set_away: + w.command(server, "/away %s" % w.config_get_plugin('message')); AWAY = True - if w.config_get_plugin("command_on_detach"): - w.command("", w.config_get_plugin("command_on_detach")) + for cmd in w.config_get_plugin("command_on_detach").split(";"): + w.command("", cmd) return w.WEECHAT_RC_OK diff -Nru weechat-scripts-20130123/python/server_autoswitch.py weechat-scripts-20131007/python/server_autoswitch.py --- weechat-scripts-20130123/python/server_autoswitch.py 2013-01-23 19:00:16.000000000 +0000 +++ weechat-scripts-20131007/python/server_autoswitch.py 2013-10-07 12:14:48.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2012 by nils_2 +# Copyright (c) 2012-2013 by nils_2 # # cylce to currently used server if you are using merged server buffer # @@ -17,6 +17,9 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-01-25: nils_2, (freenode.#weechat) +# 0.4 : make script compatible with Python 3.x +# # 2012-01-28: nils_2,(freenode.#weechat) # 0.3 : adapted to bugfix #31158 and new signal hook_signal("window_switch") # @@ -33,13 +36,13 @@ import weechat,re except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = "server_autoswitch" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.3" +SCRIPT_VERSION = "0.4" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "cycle to currently used server if you are using merged server buffer" @@ -94,7 +97,7 @@ # switch though all server and stop at server from current buffer i = 0 while i <= len(SERVER): - for servername,full_name in SERVER.items(): + for servername,full_name in list(SERVER.items()): bufpointer = weechat.buffer_search("irc","%s" % full_name) # search pointer from server buffer if bufpointer == "": # core buffer if weechat.buffer_get_integer(weechat.buffer_search_main(),'active') == 1: diff -Nru weechat-scripts-20130123/python/shell.py weechat-scripts-20131007/python/shell.py --- weechat-scripts-20130123/python/shell.py 2013-01-23 19:00:06.000000000 +0000 +++ weechat-scripts-20131007/python/shell.py 2013-10-07 12:14:39.000000000 +0000 @@ -10,6 +10,8 @@ # # ### changelog ### # +# * version 0.8, 2013-07-27, Sebastien Helleu : +# - don't remove empty lines in output of command # * version 0.7, 2012-11-26, Sebastien Helleu : # - use hashtable for command arguments (for WeeChat >= 0.4.0) # * version 0.6, 2012-11-21, Sebastien Helleu : @@ -33,7 +35,7 @@ SCRIPT_NAME = 'shell' SCRIPT_AUTHOR = 'Kolter' -SCRIPT_VERSION = '0.7' +SCRIPT_VERSION = '0.8' SCRIPT_LICENSE = 'GPL2' SCRIPT_DESC = 'Run shell commands in WeeChat' @@ -91,31 +93,29 @@ cmd_stderr += stderr if int(rc) >= 0: if cmd_stdout: - lines = cmd_stdout.split('\n') + lines = cmd_stdout.rstrip().split('\n') if cmd_send_to_buffer == 'current': for line in lines: - if line: - weechat.command(cmd_buffer, '%s' % line) + weechat.command(cmd_buffer, '%s' % line) else: + weechat.prnt(cmd_buffer, '') if cmd_send_to_buffer != 'new': weechat.prnt(cmd_buffer, '%sCommand "%s" (rc %d), stdout:' % (SHELL_PREFIX, data, int(rc))) for line in lines: - if line: - weechat.prnt(cmd_buffer, ' \t%s' % line) + weechat.prnt(cmd_buffer, ' \t%s' % line) if cmd_stderr: - lines = cmd_stderr.split('\n') + lines = cmd_stderr.rstrip().split('\n') if cmd_send_to_buffer == 'current': for line in lines: - if line: - weechat.command(cmd_buffer, '%s' % line) + weechat.command(cmd_buffer, '%s' % line) else: + weechat.prnt(cmd_buffer, '') if cmd_send_to_buffer != 'new': weechat.prnt(cmd_buffer, '%s%sCommand "%s" (rc %d), stderr:' % (weechat.prefix('error'), SHELL_PREFIX, data, int(rc))) for line in lines: - if line: - weechat.prnt(cmd_buffer, '%s%s' % (weechat.prefix('error'), line)) + weechat.prnt(cmd_buffer, '%s%s' % (weechat.prefix('error'), line)) cmd_hook_process = '' shell_set_title() return weechat.WEECHAT_RC_OK diff -Nru weechat-scripts-20130123/python/spell_correction.py weechat-scripts-20131007/python/spell_correction.py --- weechat-scripts-20130123/python/spell_correction.py 2013-01-23 19:00:18.000000000 +0000 +++ weechat-scripts-20131007/python/spell_correction.py 2013-10-07 12:14:50.000000000 +0000 @@ -17,6 +17,18 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-06-27: nils_2, (freenode.#weechat) +# 0.5 : fix: bug with root input bar +# +# 2013-02-16: nils_2, (freenode.#weechat) +# 0.4 : bug with empty localvar removed (reported by swimmer) +# +# 2013-01-31: nils_2, (freenode.#weechat) +# 0.3 : using new info "aspell_dict" (weechat >= 0.4.1) +# +# 2013-01-25: nils_2, (freenode.#weechat) +# 0.2 : make script compatible with Python 3.x +# # 2012-01-13: nils_2, (freenode.#weechat) # 0.1 : - initial release - # @@ -25,12 +37,8 @@ # Development is currently hosted at # https://github.com/weechatter/weechat-scripts # -# TODO: -# I would also appreciate it if it would list from which dictionary the suggestion came. (FiXato) -# a simple work around is implemented. see source for further information (def get_localvar_dict(buffer):) -# try: - import weechat, re, sys + import weechat, re #sys except Exception: print("This script must be run under WeeChat.") @@ -39,7 +47,7 @@ SCRIPT_NAME = "spell_correction" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.1" +SCRIPT_VERSION = "0.5" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "a simple spell correction for a 'misspelled' word" @@ -58,7 +66,8 @@ multiline_input = 0 # ================================[ weechat options & description ]=============================== def init_options(): - for option,value in OPTIONS.items(): + for option,value in list(OPTIONS.items()): +# for option,value in OPTIONS.items(): weechat.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) if not weechat.config_is_set_plugin(option): weechat.config_set_plugin(option, value[0]) @@ -140,7 +149,14 @@ weechat.bar_item_update('spell_correction') return weechat.WEECHAT_RC_OK -def show_item_cb (data, item, window): + +# spell_correction_suggest_item: +def show_spell_correction_item_cb (data, item, window): + + # check for root input bar! + if not window: + window = weechat.current_window() +# weechat.buffer_get_string(buffer,'localvar_spell_correction_suggest_item'): buffer = weechat.window_get_pointer(window,"buffer") if buffer == '': @@ -165,7 +181,7 @@ if dicts_found: # aspell.dict.full_name = en_GB,de_DE-neu # localvar_dict = en_GB,de_DE-neu - dictionary = get_localvar_dict(buffer) + dictionary = get_aspell_dict_for(buffer) if not dictionary: return aspell_suggest_item dictionary_list = dictionary.split(',') @@ -191,7 +207,7 @@ if config_spell_suggest_item: show_item = config_spell_suggest_item.replace('%S',aspell_suggest_item) if weechat.config_get_plugin('hide_single_dict').lower() == 'off': - show_item = show_item.replace('%D',get_localvar_dict(buffer)) + show_item = show_item.replace('%D',get_aspell_dict_for(buffer)) else: show_item = show_item.replace('%D','').rstrip() @@ -232,6 +248,11 @@ def replace_misspelled_word(buffer): input_line = weechat.buffer_get_string(buffer, 'localvar_spell_correction_suggest_input_line') + if not input_line: + # remove spell_correction item + weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '') + weechat.bar_item_update('spell_correction') + return if OPTIONS['eat_input_char'].lower() == 'off' or input_line == '': input_pos = weechat.buffer_get_integer(buffer,'input_pos') # check cursor position @@ -280,14 +301,17 @@ def get_localvar_aspell_suggest(buffer): return weechat.buffer_get_string(buffer, 'localvar_aspell_suggest') -def get_localvar_dict(buffer): - # TODO: this is a "simple" work around and its only working for buffers with given dictionary - # no fallback for partial name like "aspell.dict.irc". - # WeeChat 0.4.1 will offer a new function to get the dict from a buffer in a correct manner +def get_aspell_dict_for(buffer): + # this should never happens, but to be sure. Otherwise WeeChat will crash + if buffer == '': + return '' + if int(version) >= 0x00040100: + return weechat.info_get("aspell_dict", buffer) + # this is a "simple" work around and it only works for buffers with given dictionary + # no fallback for partial name like "aspell.dict.irc". Get your hands on WeeChat 0.4.1 full_name = weechat.buffer_get_string(buffer,'full_name') return weechat.config_string(weechat.config_get('aspell.dict.%s' % weechat.buffer_get_string(buffer,'full_name'))) -# return weechat.buffer_get_string(buffer, 'localvar_aspell_dict') def substitute_colors(text): # substitute colors in output @@ -305,6 +329,7 @@ if OPTIONS['auto_pop_up_item'].lower() == 'on': auto_suggest_cmd_cb('', buffer, '') weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_input_line', '') + weechat.bar_item_update('spell_suggest') return weechat.WEECHAT_RC_OK def get_last_position_of_misspelled_word(misspelled_word, buffer): @@ -349,6 +374,7 @@ weechat.buffer_set(buffer, 'localvar_set_spell_correction_suggest_item', '%s:%s:%s' % ('2',position,aspell_suggest_item)) auto_suggest_cmd_cb('', buffer, command) + weechat.bar_item_update('spell_suggest') return weechat.WEECHAT_RC_OK # if a suggestion is selected and you press [RETURN] replace misspelled word! @@ -393,6 +419,42 @@ weechat.buffer_set(buffer, 'localvar_set_spell_correction_suggest_item', '%s:%s:%s' % ('1',position,aspell_suggest_item)) return weechat.WEECHAT_RC_OK + +# aspell_suggest: "mispelled:mi spelled,mi-spelled,misspelled" +# weechat.bar_item_update('spell_suggest') +def show_spell_suggestion_item_cb (data, item, window): + buffer = weechat.window_get_pointer(window,"buffer") + if buffer == '': + return '' + + tab_complete,position,aspell_suggest_item = get_position_and_suggest_item(buffer) + localvar_aspell_suggest = get_localvar_aspell_suggest(buffer) + + # localvar_aspell_suggest = word,word2/wort,wort2 + if localvar_aspell_suggest: + misspelled_word,aspell_suggestions = localvar_aspell_suggest.split(':') + aspell_suggestions_orig = aspell_suggestions + aspell_suggestions = aspell_suggestions.replace('/',',') + aspell_suggestion_list = aspell_suggestions.split(',') + + if not position: + return '' + if int(position) < len(aspell_suggestion_list): + reset_color = weechat.color('reset') + color = weechat.color("red") + new_word = aspell_suggestion_list[int(position)].replace(aspell_suggestion_list[int(position)],'%s%s%s' % (color, aspell_suggestion_list[int(position)], reset_color)) +# weechat.prnt("",new_word) + else: + return '' + + return aspell_suggestions_orig + +def window_switch_cb(data, signal, signal_data): + weechat.bar_item_update('spell_correction') + return weechat.WEECHAT_RC_OK +def buffer_switch_cb(data, signal, signal_data): + weechat.bar_item_update('spell_correction') + return weechat.WEECHAT_RC_OK # ================================[ main ]=============================== if __name__ == "__main__": if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', ''): @@ -430,9 +492,13 @@ weechat.hook_signal ('aspell_suggest', 'aspell_suggest_cb', '') + weechat.hook_signal ('buffer_switch', 'buffer_switch_cb','') + weechat.hook_signal ('window_switch', 'window_switch_cb','') + if OPTIONS['catch_input_completion'].lower() == "on": Hooks['catch_input_completion'] = weechat.hook_command_run('/input complete*', 'input_complete_cb', '') Hooks['catch_input_return'] = weechat.hook_command_run('/input return', 'input_return_cb', '') weechat.hook_config('plugins.var.python.' + SCRIPT_NAME + '.*', 'toggle_refresh', '') - weechat.bar_item_new('spell_correction', 'show_item_cb', '') + weechat.bar_item_new('spell_correction', 'show_spell_correction_item_cb', '') + weechat.bar_item_new('spell_suggest', 'show_spell_suggestion_item_cb', '') # weechat.prnt("","%s" % sys.version_info) diff -Nru weechat-scripts-20130123/python/stick_buffer.py weechat-scripts-20131007/python/stick_buffer.py --- weechat-scripts-20130123/python/stick_buffer.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/stick_buffer.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,145 @@ +# -*- coding: utf-8 -*- +# +# Copyright (c) 2013 by nils_2 +# +# stick buffer to a window, irssi like +# +# 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 . +# +# idea by shad0VV@freenode.#weechat +# +# 2013-01-25: nils_2, (freenode.#weechat) +# 0.2 : make script compatible with Python 3.x +# : smaller improvements +# +# 2013-01-21: nils_2, (freenode.#weechat) +# 0.1 : initial release +# +# requires: WeeChat version 0.3.0 +# +# Development is currently hosted at +# https://github.com/weechatter/weechat-scripts + +try: + import weechat, sys + +except Exception: + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") + quit() + +SCRIPT_NAME = "stick_buffer" +SCRIPT_AUTHOR = "nils_2 " +SCRIPT_VERSION = "0.2" +SCRIPT_LICENSE = "GPL" +SCRIPT_DESC = "stick buffer to a window, irssi like" + +# ===============================[ infolist() ]============================= +def infolist_get_buffer_name_and_ptr(str_buffer_number): + infolist = weechat.infolist_get('buffer', '', '') + full_name = '' + ptr_buffer = '' + if infolist: + while weechat.infolist_next(infolist): + if int(str_buffer_number) == weechat.infolist_integer(infolist, 'number'): + full_name = weechat.infolist_string(infolist, 'full_name') + ptr_buffer = weechat.infolist_pointer(infolist, 'pointer') + break + weechat.infolist_free(infolist) + return full_name, ptr_buffer + +def get_current_buffer_number(): + ptr_buffer = weechat.window_get_pointer(weechat.current_window(), 'buffer') + return weechat.buffer_get_integer(ptr_buffer, 'number') + +# return empty string if no number is found +def get_buffer_number_as_string(data): + if sys.version_info < (3,): + return filter(lambda x: x.isdigit(), data) + return [x for x in data if x.isdigit()] + +# ===============================[ callback() ]============================= +def buffer_switch_cb(signal, callback, callback_data): + if callback_data == '': + return weechat.WEECHAT_RC_OK + + argv = callback_data.strip().split(' ',)[1:] + if len(argv) == 0 or len(argv) > 1: + return weechat.WEECHAT_RC_OK + + # check out if string is a number + str_buffer_number = get_buffer_number_as_string(argv[0]) + if not str_buffer_number: + return weechat.WEECHAT_RC_OK + + curren_buffer_number = get_current_buffer_number() + if not curren_buffer_number: + return weechat.WEECHAT_RC_OK + if argv[0][0] == '-': + switch_to_buffer = curren_buffer_number - int(argv[0][1:]) # [1:] don't use first sign + if switch_to_buffer < 1: + switch_to_buffer = 1 + elif argv[0][0] == '+': + switch_to_buffer = curren_buffer_number + int(argv[0][1:]) # [1:] don't use first sign + else: + switch_to_buffer = int(str_buffer_number[0]) + + buffer_name, ptr_buffer = infolist_get_buffer_name_and_ptr(switch_to_buffer) + if not buffer_name or not ptr_buffer: + return weechat.WEECHAT_RC_OK + + if ptr_buffer == weechat.window_get_pointer(weechat.current_window(),'buffer'): + return weechat.WEECHAT_RC_OK + + window_number = weechat.buffer_get_string(ptr_buffer,'localvar_stick_buffer_to_window') + if window_number: + weechat.command('','/window %s' % window_number) + return weechat.WEECHAT_RC_OK + + +def open_buffer_cmd_cb(data, buffer, args): + argv = args.strip().split(' ', 1) + if len(argv) == 0: + return weechat.WEECHAT_RC_OK + + if argv[0].lower() == 'list': + weechat.command('','/set *.localvar_set_stick_buffer_to_window') + + return weechat.WEECHAT_RC_OK +# ================================[ main ]=============================== +if __name__ == "__main__": + if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', ''): + version = weechat.info_get("version_number", "") or 0 + + weechat.hook_command(SCRIPT_NAME, SCRIPT_DESC, 'list', + '\n' + 'You have to create a localvar, \"stick_buffer_to_window\", for the buffer you want to stick to a specific window.\n' + 'You will need script \"buffer_autoset.py\" to make local variabe persistent (see examples, below)!!\n' + '\n' + 'Examples:\n' + ' temporarily stick the current buffer to window 3:\n' + ' /buffer set localvar_set_stick_buffer_to_window 3\n' + ' stick buffer #weechat to window 2:\n' + ' /autosetbuffer add irc.freenode.#weechat stick_buffer_to_window 2\n' + ' lists buffer who are bind to a specific window (only persistent ones!):\n' + ' /' + SCRIPT_NAME + ' list\n' + ' display local variables for current buffer:\n' + ' /buffer localvar\n' + '', + 'list %-', + 'open_buffer_cmd_cb', '') + + weechat.hook_command_run('/buffer *', 'buffer_switch_cb', '') +# weechat.prnt("","%s.%s" % (sys.version_info[0], sys.version_info[1])) + diff -Nru weechat-scripts-20130123/python/text_item.py weechat-scripts-20131007/python/text_item.py --- weechat-scripts-20130123/python/text_item.py 2013-01-23 19:00:18.000000000 +0000 +++ weechat-scripts-20131007/python/text_item.py 2013-10-07 12:14:50.000000000 +0000 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2012 by nils_2 +# Copyright (c) 2012-2013 by nils_2 # # add a plain text to item bar # @@ -17,6 +17,12 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +# 2013-06-27: nils_2, (freenode.#weechat) +# 0.3 : fix: bug with root bar +# +# 2013-01-25: nils_2, (freenode.#weechat) +# 0.2 : make script compatible with Python 3.x +# # 2012-12-23: nils_2, (freenode.#weechat) # 0.1 : initial release # @@ -47,13 +53,13 @@ import weechat,re except Exception: - print "This script must be run under WeeChat." - print "Get WeeChat now at: http://www.weechat.org/" + print("This script must be run under WeeChat.") + print("Get WeeChat now at: http://www.weechat.org/") quit() SCRIPT_NAME = "text_item" SCRIPT_AUTHOR = "nils_2 " -SCRIPT_VERSION = "0.1" +SCRIPT_VERSION = "0.3" SCRIPT_LICENSE = "GPL" SCRIPT_DESC = "add a plain text to item bar" @@ -83,6 +89,10 @@ if not data: return "" + # window empty? root bar! + if not window: + window = weechat.current_window() + value = weechat.config_get_plugin(data) if value: diff -Nru weechat-scripts-20130123/python/twitter.py weechat-scripts-20131007/python/twitter.py --- weechat-scripts-20130123/python/twitter.py 2013-01-23 19:00:17.000000000 +0000 +++ weechat-scripts-20131007/python/twitter.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,82 +0,0 @@ -""" - twitter.py - - author: Jimmy Zelinskie - desc: Sends your latest tweet to the current buffer - usage: - /set plugins.var.python.twitter.twitter_handle yourusername - /twitter - license: GPL3 - - history: - - 0.1 - initial script - Jimmy Zelinskie - - 0.0 - forked from lastfm.py by - Adam Saponara - -""" - -import weechat -import feedparser - -weechat.register("twitter", "Jimmy Zelinskie", "0.1", "GPL3", "Sends your latest tweet to the current buffer", "", "") - -defaults = { - "twitter_handle" : "nobody", - "command" : "/me last tweeted: %s" -} - -cmd_hook_process = "" -cmd_buffer = "" -cmd_stdout = "" -cmd_stderr = "" - -for k, v in defaults.iteritems(): - if not weechat.config_is_set_plugin(k): - weechat.config_set_plugin(k, v) - -def twitter_cmd(data, buffer, args): - global cmd_hook_process, cmd_buffer, cmd_stdout, cmd_stderr - if cmd_hook_process != "": - weechat.prnt(buffer, "Twitter is already running!") - return weechat.WEECHAT_RC_OK - cmd_buffer = buffer - cmd_stdout = "" - cmd_stderr = "" - python2_bin = weechat.info_get("python2_bin", "") or "python" - cmd_hook_process = weechat.hook_process( - python2_bin + " -c \"\n" - "import sys, feedparser\n" - "feed = None\n" - "feed = feedparser.parse('http://api.twitter.com/1/statuses/user_timeline.rss?screen_name=%(username)s')\n" - "if not feed or feed.bozo:\n" - " print >>sys.stderr, 'Could not fetch Twitter RSS feed.',\n" - "elif not 'items' in feed or len(feed['items']) < 1:\n" - " print >>sys.stderr, 'No tweets found in Twitter RSS feed.',\n" - "else:\n" - " print '@'+feed['items'][0]['title'].replace(u'\u2013', '-').encode('utf-8', 'replace'),\n" - "\"" % {"username" : weechat.config_get_plugin('twitter_handle')}, - 10000, "twitter_cb", "") - return weechat.WEECHAT_RC_OK - -def twitter_cb(data, command, rc, stdout, stderr): - global cmd_hook_process, cmd_buffer, cmd_stdout, cmd_stderr - cmd_stdout += stdout - cmd_stderr += stderr - if int(rc) >= 0: - if cmd_stderr != "": - weechat.prnt(cmd_buffer, "%s" % cmd_stderr) - if cmd_stdout != "": - weechat.command(cmd_buffer, weechat.config_get_plugin("command") % cmd_stdout) - cmd_hook_process = "" - return weechat.WEECHAT_RC_OK - -hook = weechat.hook_command( - "twitter", - "Sends your latest tweet to the current buffer. Before using /twitter, set your twitter handle like this:\n\n" - " /set plugins.var.python.twitter.twitter_handle yourhandle\n\n" - "You can also customize the command that will be sent to the buffer like this:\n\n" - " /set plugins.var.python.twitter.command I last tweeted %s\n", - "", "", "", "twitter_cmd", "") diff -Nru weechat-scripts-20130123/python/typing_counter.py weechat-scripts-20131007/python/typing_counter.py --- weechat-scripts-20130123/python/typing_counter.py 2013-01-23 19:00:10.000000000 +0000 +++ weechat-scripts-20131007/python/typing_counter.py 2013-10-07 12:14:43.000000000 +0000 @@ -1,4 +1,4 @@ -# Copyright (c) 2010-2012 by fauno +# Copyright (c) 2010-2013 by fauno # # Bar item showing typing count. Add 'tc' to a bar. # @@ -29,6 +29,17 @@ # 0.3 : # added sound-alarm when cursor position is -1 or higher than 'max_chars' # improved option-handling +# 0.4 : +# fix display bug with more than one window +# 0.5 : +# add description for options +# add tweet and sms counter for bitlbee and gtalksms (suggested by ahuemer@freenode) +# 0.6 : +# add support for gtalksms "reply" (suggested by ahuemer@freenode) +# 0.7 : +# fix bug with root bar (reported by fours_) +# 0.8 : +# fix regex bug with ":" in sms text (reported by ahuemer) # # Note: As of version 0.2 this script requires a version of weechat # from git 2010-01-25 or newer, or at least 0.3.2 stable. @@ -38,7 +49,7 @@ # # config: # %P = cursor position -# %L = input lenght +# %L = input length # %R = reverse counting from max_chars # %C = displays how many chars are count over max_chars # /set plugins.var.python.typing_counter.format "[%P|%L|<%R|%C>]" @@ -61,7 +72,7 @@ SCRIPT_NAME = "typing_counter" SCRIPT_AUTHOR = "fauno " -SCRIPT_VERSION = "0.3" +SCRIPT_VERSION = "0.8" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "Bar item showing typing count and cursor position. Add 'tc' to a bar." @@ -73,7 +84,7 @@ print "Get WeeChat now at: http://www.weechat.org/" quit() try: - import os, sys + import os, sys, re except ImportError as message: print('Missing package(s) for %s: %s' % (SCRIPT_NAME, message)) @@ -85,11 +96,13 @@ count_over = '0' tc_default_options = { - 'format' : '[%P|%L|<%R|%C>]', - 'warn' : '140', - 'warn_colour' : 'red', - 'max_chars' : '200', - 'warn_command' : '', + 'format' : ('[%P|%L|<%R|%C>]','item name to add in a bar is "tc". item format is: %P = cursor position, %L = input length, %R = reverse counting from max_chars, %C = displays how many chars are count over max_chars'), + 'warn' : ('140','turns indicator to "warn_colour" when position is reached'), + 'warn_colour' : ('red','color for warn after specified number of chars'), + 'max_chars' : ('200','max number of chars to count reverse'), + 'warn_command' : ('', 'to activate a display beep use: $beep'), + 'tweet_buffer' : ('bitlbee.#tweet','name of tweet buffer. This is a comma separated list'), + 'sms_buffer' : ('bitlbee.sms','name of sms buffer (using gtalksms). This is a comma separated list'), } tc_options = {} @@ -108,20 +121,88 @@ '''May be used as a callback or standalone call.''' global length, cursor_pos, tc_input_text - current_buffer = w.current_buffer() - length = w.buffer_get_integer(current_buffer,'input_length') - cursor_pos = w.buffer_get_integer(current_buffer,'input_pos') + 1 w.bar_item_update('tc') return w.WEECHAT_RC_OK def tc_bar_item (data, item, window): '''Item constructor''' + # window empty? root bar! + if not window: + window = w.current_window() + global length, cursor_pos, tc_input_text, count_over,tc_options count_over = '0' + sms = '' + tweet = '' + reverse_chars = 0 + + bufpointer = w.window_get_pointer(window,"buffer") + if bufpointer == "": + return "" + + length = w.buffer_get_integer(bufpointer,'input_length') + cursor_pos = w.buffer_get_integer(bufpointer,'input_pos') + 1 + + plugin = w.buffer_get_string(bufpointer, 'plugin') + + host = '' + if plugin == 'irc': + servername = w.buffer_get_string(bufpointer, 'localvar_server') + channelname = w.buffer_get_string(bufpointer, 'localvar_channel') + channel_type = w.buffer_get_string(bufpointer, 'localvar_type') + name = w.buffer_get_string(bufpointer, 'localvar_name') + input_line = w.buffer_get_string(bufpointer, 'input') + mynick = w.info_get('irc_nick', servername) + nick_ptr = w.nicklist_search_nick(bufpointer, '', mynick) + + # check for a sms message + if channel_type == 'private' and name in tc_options['sms_buffer'].split(","): + # 160 chars for a sms + # 'sms:name:text' + get_sms_text = re.match(r'(s|sms):(.*?:)(.*)', input_line) + if get_sms_text: +# if get_sms_text.group(2): + sms_len = len(get_sms_text.group(3)) +# input_length = len(input_line) +# sms_prefix = input_length - sms_len + sms = 160-sms_len + reverse_chars = sms + else: + get_sms_text = re.match(r'(r|reply):(.*)', input_line) + if get_sms_text: + sms_len = len(get_sms_text.group(2)) + sms = 160-sms_len + reverse_chars = sms + + # check for a tweet buffer + elif name in tc_options['tweet_buffer'].split(","): + # 140 chars for a tweet! prefix "post " = 5 chars + + # check out if length >= 5 and matches "post " + if length >= 5 and re.match(r'post (.*)', input_line): + tweet = 145 - length + reverse_chars = tweet + + # get host and length from host + elif servername != channelname: + infolist = w.infolist_get('irc_nick', '', '%s,%s,%s' % (servername,channelname,mynick)) +# w.prnt("","%s.%s.%s.%s" % (servername,channelname,mynick,nick_ptr)) + while w.infolist_next(infolist): + host = w.infolist_string(infolist, 'host') + w.infolist_free(infolist) + if host != '': + host = ':%s!%s PRIVMSG %s :' % (mynick,host,channelname) + host_length = len(host) +# w.prnt("","%d" % host_length) + reverse_chars = (475 - int(host_length) - length -1) # -1 = return + else: + reverse_chars = (int(tc_options['max_chars']) - length) + else: + reverse_chars = (int(tc_options['max_chars']) - length) + else: + # reverse check for max_chars + reverse_chars = (int(tc_options['max_chars']) - length) - # reverse check for max_chars - reverse_chars = (int(tc_options['max_chars']) - length) -# reverse_chars = (int(max_chars) - length) if reverse_chars == 0: reverse_chars = "%s" % ("0") else: @@ -131,26 +212,41 @@ tc_action_cb() else: reverse_chars = str(reverse_chars) + out_format = tc_options['format'] - if length >= int(tc_options['warn']): - length_warn = "%s%s%s" % (w.color(tc_options['warn_colour']), str(length), w.color('default')) - out_format = out_format.replace('%L', length_warn) + if tc_options['warn']: + if length >= int(tc_options['warn']): + length_warn = "%s%s%s" % (w.color(tc_options['warn_colour']), str(length), w.color('default')) + out_format = out_format.replace('%L', length_warn) + else: + out_format = out_format.replace('%L', str(length)) else: - out_format = out_format.replace('%L', str(length)) + out_format = out_format.replace('%L', str(length)) out_format = out_format.replace('%P', str(cursor_pos)) - out_format = out_format.replace('%R', reverse_chars) + if sms: + out_format = out_format.replace('%R', "s:" + reverse_chars) + elif tweet: + out_format = out_format.replace('%R', "t:" + reverse_chars) + else: + out_format = out_format.replace('%R', reverse_chars) out_format = out_format.replace('%C', count_over) +# out_format = out_format.replace('%T', str(tweet)) +# out_format = out_format.replace('%S', str(sms)) tc_input_text = out_format return tc_input_text def init_config(): global tc_default_options, tc_options - for option, default_value in tc_default_options.items(): + + for option,value in list(tc_default_options.items()): + w.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0])) if not w.config_is_set_plugin(option): - w.config_set_plugin(option, default_value) - tc_options[option] = w.config_get_plugin(option) + w.config_set_plugin(option, value[0]) + tc_options[option] = value[0] + else: + tc_options[option] = w.config_get_plugin(option) def config_changed(data, option, value): init_config() diff -Nru weechat-scripts-20130123/python/urlserver.py weechat-scripts-20131007/python/urlserver.py --- weechat-scripts-20130123/python/urlserver.py 2013-01-23 19:00:16.000000000 +0000 +++ weechat-scripts-20131007/python/urlserver.py 2013-10-07 12:14:47.000000000 +0000 @@ -1,8 +1,10 @@ # -*- coding: utf-8 -*- # -# Copyright (C) 2011-2012 Sebastien Helleu +# Copyright (C) 2011-2013 Sebastien Helleu # Copyright (C) 2011 xt # Copyright (C) 2012 Filip H.F. "FiXato" Slagter +# Copyright (C) 2012 WillyKaze +# Copyright (C) 2013 Thomas Kindler # # 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 @@ -33,10 +35,14 @@ # 4. It is recommended to customize/protect the HTTP server using script options # (see /help urlserver) # -# Example: +# Example after message: # -# FlashCode | look at this: http://test.server.com/this-is-a-very-looooong-url -# | http://myhost.org:1234/8aK +# FlashCode | look at this: http://test.server.com/this-is-a-long-url +# | [ http://myhost.org:1234/8aK ] +# +# Example inside message: +# +# FlashCode | look at this: http://test.server.com/this-is-a-long-url [ http://myhost.org:1234/8aK ] # # List of URLs: # - in WeeChat: /urlserver @@ -44,6 +50,15 @@ # # History: # +# 2013-05-04, Thomas Kindler +# version 1.2: added a "http_scheme_display" option. This makes it possible to run +# the server behind a reverse proxy with https:// URLs. +# 2013-03-25, Hermit (@irc.freenode.net): +# version 1.1: made links relative in the html, so that they can be followed when accessing +# the listing remotely using the weechat box's IP directly. +# 2012-12-12, WillyKaze : +# version 1.0: add options "http_time_format", "display_msg_in_url" (works with relay/irc), +# "color_in_msg", "separators" # 2012-04-18, Filip H.F. "FiXato" Slagter : # version 0.9: add options "http_autostart", "http_port_display" # "url_min_length" can now be set to -1 to auto-detect minimal url length @@ -73,7 +88,7 @@ SCRIPT_NAME = 'urlserver' SCRIPT_AUTHOR = 'Sebastien Helleu ' -SCRIPT_VERSION = '0.9' +SCRIPT_VERSION = '1.2' SCRIPT_LICENSE = 'GPL3' SCRIPT_DESC = 'Shorten URLs with own HTTP server' @@ -114,6 +129,7 @@ urlserver_settings_default = { # HTTP server settings 'http_autostart' : ('on', 'start the built-in HTTP server automatically)'), + 'http_scheme_display': ('http', 'display this scheme in shortened URLs'), 'http_hostname' : ('', 'force hostname/IP in bind of socket (empty value = auto-detect current hostname)'), 'http_hostname_display': ('', 'display this hostname in shortened URLs'), 'http_port' : ('', 'force port for listening (empty value = find a random free port)'), @@ -129,6 +145,7 @@ 'http_embed_youtube_size': ('480*350', 'size for embedded youtube video, format is "xxx*yyy"'), 'http_prefix_suffix' : (' ', 'suffix displayed between prefix and message in HTML page'), 'http_title' : ('WeeChat URLs', 'title of the HTML page'), + 'http_time_format' : ('%d/%m/%y %H:%M:%S', 'time format in the HTML page'), # message filter settings 'msg_ignore_buffers' : ('core.weechat,python.grep', 'comma-separated list (without spaces) of buffers to ignore (full name like "irc.freenode.#weechat")'), 'msg_ignore_tags' : ('irc_quit,irc_part,notify_none', 'comma-separated list (without spaces) of tags (or beginning of tags) to ignore (for example, use "notify_none" to ignore self messages or "nick_weebot" to ignore messages from nick "weebot")'), @@ -136,8 +153,11 @@ 'msg_ignore_regex' : ('', 'ignore messages matching this regex'), 'msg_ignore_dup_urls': ('off', 'ignore duplicated URLs (do not add an URL in list if it is already)'), # display settings - 'color' : ('darkgray', 'color for urls displayed'), + 'color' : ('darkgray', 'color for urls displayed after message'), + 'color_in_msg' : ('', 'color for urls displayed inside irc message: it is a number (irc color) between 00 and 15 (see doc for a list of irc colors)'), + 'separators' : ('[|]', 'separators for short url list (string with exactly 3 chars)'), 'display_urls' : ('on', 'display URLs below messages'), + 'display_urls_in_msg': ('off', 'add shorten url next to the original url (only in IRC messages) (useful for urlserver behind relay/irc)'), 'url_min_length' : ('0', 'minimum length for an URL to be shortened (0 = shorten all URLs, -1 = detect length based on shorten URL)'), 'urls_amount' : ('100', 'number of URLs to keep in memory (and in file when script is not loaded)'), 'buffer_short_name' : ('off', 'use buffer short name on dedicated buffer'), @@ -169,10 +189,11 @@ # python 2.x return base64.b64decode(s) -def urlserver_short_url(number): - """Return short URL with number.""" +def urlserver_get_hostname(full=True): + """Return hostname with port number if != default port for the protocol.""" global urlserver_settings + scheme = urlserver_settings['http_scheme_display'] hostname = urlserver_settings['http_hostname_display'] or urlserver_settings['http_hostname'] or socket.getfqdn() # If the built-in HTTP server isn't running, default to port from settings @@ -182,16 +203,26 @@ elif urlserver['socket']: port = urlserver['socket'].getsockname()[1] - # Don't add :port if the port matches the default port for the http protocol, port 80 + # Don't add :port if the port matches the default port for the protocol prefixed_port = ':%s' % port - if prefixed_port == ':80': + + if scheme == "http" and prefixed_port == ':80': + prefixed_port = '' + elif scheme == "https" and prefixed_port == ':443': prefixed_port = '' prefix = '' if urlserver_settings['http_url_prefix']: prefix = '%s/' % urlserver_settings['http_url_prefix'] - return 'http://%s%s/%s%s' % (hostname, prefixed_port, prefix, base62_encode(number)) + if full: + return '%s://%s%s/%s' % (scheme, hostname, prefixed_port, prefix) + else: + return '/%s' % prefix + +def urlserver_short_url(number, full=True): + """Return short URL with number.""" + return '%s%s' % (urlserver_get_hostname(full), base62_encode(number)) def urlserver_server_reply(conn, code, extra_header, message, mimetype='text/html'): """Send a HTTP reply to client.""" @@ -266,8 +297,9 @@ message = cgi.escape(item[4].replace(url, '\x01\x02\x03\x04')).split('\t', 1) message[0] = '%s' % message[0] message[1] = '%s' % message[1] + strjoin = ' %s ' % urlserver_settings['http_prefix_suffix'].replace(' ', ' ') - message = strjoin.join(message).replace('\x01\x02\x03\x04', '%s' % (urlserver_short_url(key), url, url)) + message = strjoin.join(message).replace('\x01\x02\x03\x04', '%s' % (urlserver_short_url(key, False), url, url)) if urlserver_settings['http_embed_image'] == 'on' and url.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg')): obj = '

' % (url, url, url) elif urlserver_settings['http_embed_youtube'] == 'on' and 'youtube.com/' in url: @@ -445,22 +477,26 @@ urlserver_server_stop() urlserver_server_start() -def urlserver_display_url_detail(key): +def urlserver_display_url_detail(key, return_url=False): global urlserver url = urlserver['urls'][key] nick = url[1] if nick: nick += ' @ ' - weechat.prnt_date_tags(urlserver['buffer'], 0, 'notify_none', - '%s, %s%s%s%s: %s%s%s -> %s' % (url[0], - nick, - weechat.color('chat_buffer'), - url[2], - weechat.color('reset'), - weechat.color(urlserver_settings['color']), - urlserver_short_url(key), - weechat.color('reset'), - url[3])) + + if return_url: + return urlserver_short_url(key) + else: + weechat.prnt_date_tags(urlserver['buffer'], 0, 'notify_none', + '%s, %s%s%s%s: %s%s%s -> %s' % (url[0], + nick, + weechat.color('chat_buffer'), + url[2], + weechat.color('reset'), + weechat.color(urlserver_settings['color']), + urlserver_short_url(key), + weechat.color('reset'), + url[3])) def urlserver_buffer_input_cb(data, buffer, input_data): if input_data in ('q', 'Q'): @@ -508,52 +544,49 @@ urlserver_open_buffer() return weechat.WEECHAT_RC_OK -def urlserver_print_cb(data, buffer, time, tags, displayed, highlight, prefix, message): - """Callback for messages printed in buffers.""" +def urlserver_update_urllist(buffer_full_name, buffer_short_name, tags, prefix, message, nick=None): + """Update urls list and return a list of short urls for message.""" global urlserver, urlserver_settings - buffer_full_name = '%s.%s' % (weechat.buffer_get_string(buffer, 'plugin'), weechat.buffer_get_string(buffer, 'name')) - if urlserver_settings['buffer_short_name'] == 'on': - buffer_name = weechat.buffer_get_string(buffer, 'short_name') - else: - buffer_name = buffer_full_name - - listtags = tags.split(',') - # skip ignored buffers if urlserver_settings['msg_ignore_buffers']: if buffer_full_name in urlserver_settings['msg_ignore_buffers'].split(','): - return weechat.WEECHAT_RC_OK + return None - # skip ignored tags - if urlserver_settings['msg_ignore_tags']: - for itag in urlserver_settings['msg_ignore_tags'].split(','): - for tag in listtags: - if tag.startswith(itag): - return weechat.WEECHAT_RC_OK - - # exit if a required tag is missing - if urlserver_settings['msg_require_tags']: - for rtag in urlserver_settings['msg_require_tags'].split(','): - tagfound = False - for tag in listtags: - if tag.startswith(rtag): - tagfound = True - break - if not tagfound: - return weechat.WEECHAT_RC_OK + listtags = [] + if tags: + listtags = tags.split(',') + + # skip ignored tags + if urlserver_settings['msg_ignore_tags']: + for itag in urlserver_settings['msg_ignore_tags'].split(','): + for tag in listtags: + if tag.startswith(itag): + return None + + # exit if a required tag is missing + if urlserver_settings['msg_require_tags']: + for rtag in urlserver_settings['msg_require_tags'].split(','): + tagfound = False + for tag in listtags: + if tag.startswith(rtag): + tagfound = True + break + if not tagfound: + return None # ignore message is matching the "msg_ignore_regex" if urlserver_settings['msg_ignore_regex']: if re.search(urlserver_settings['msg_ignore_regex'], prefix + '\t' + message): - return weechat.WEECHAT_RC_OK + return None # extract nick from tags - nick = '' - for tag in listtags: - if tag.startswith('nick_'): - nick = tag[5:] - break + if not nick: + nick = '' + for tag in listtags: + if tag.startswith('nick_'): + nick = tag[5:] + break # get URL min length min_length = 0 @@ -566,18 +599,19 @@ min_length = 0 # shorten URL(s) in message + urls_short = [] for url in urlserver['regex'].findall(message): if len(url) >= min_length: if urlserver_settings['msg_ignore_dup_urls'] == 'on': if [key for key, value in urlserver['urls'].items() if value[3] == url]: continue number = urlserver['number'] - urlserver['urls'][number] = (datetime.datetime.now().strftime('%d/%m/%y %H:%M'), nick, buffer_name, url, '%s\t%s' % (prefix, message)) - if urlserver_settings['display_urls'] == 'on': - weechat.prnt_date_tags(buffer, 0, 'no_log,notify_none', '%s%s' % (weechat.color(urlserver_settings['color']), urlserver_short_url(number))) - if urlserver['buffer']: - urlserver_display_url_detail(number) - urlserver['number'] += 1 + if not url.startswith(urlserver_get_hostname()): # don't save urls already shorten + urlserver['urls'][number] = (datetime.datetime.now().strftime(urlserver_settings['http_time_format']), nick, buffer_short_name, url, '%s\t%s' % (prefix, message)) + urls_short.append(urlserver_short_url(number)) + if urlserver['buffer']: + urlserver_display_url_detail(number) + urlserver['number'] += 1 # remove old URLs if we have reach max list size urls_amount = 50 @@ -591,8 +625,76 @@ keys = sorted(urlserver['urls']) del urlserver['urls'][keys[0]] + return urls_short + +def urlserver_print_cb(data, buffer, time, tags, displayed, highlight, prefix, message): + """Callback for message printed in buffer: display short URLs after message.""" + global urlserver, urlserver_settings + + if urlserver_settings['display_urls'] == 'on': + buffer_full_name = '%s.%s' % (weechat.buffer_get_string(buffer, 'plugin'), weechat.buffer_get_string(buffer, 'name')) + if urlserver_settings['buffer_short_name'] == 'on': + buffer_short_name = weechat.buffer_get_string(buffer, 'short_name') + else: + buffer_short_name = buffer_full_name + urls_short = urlserver_update_urllist(buffer_full_name, buffer_short_name, tags, prefix, message) + if urls_short: + if urlserver_settings['separators'] and len(urlserver_settings['separators']) == 3: + separator = ' %s ' % (urlserver_settings['separators'][1]) + urls_string = separator.join(urls_short) + urls_string = '%s %s %s' % (urlserver_settings['separators'][0], urls_string, urlserver_settings['separators'][2]) + else: + urls_string = ' | '.join(urls_short) + urls_string = '[ ' + urls_string + ' ]' + weechat.prnt_date_tags(buffer, 0, 'no_log,notify_none', '%s%s' % (weechat.color(urlserver_settings['color']), urls_string)) + return weechat.WEECHAT_RC_OK +def urlserver_modifier_irc_cb(data, modifier, modifier_data, string): + """Modifier for IRC message: add short URLs at the end of IRC message.""" + global urlserver, urlserver_settings + + if urlserver_settings['display_urls_in_msg'] != 'on': + return string + + msg = weechat.info_get_hashtable('irc_message_parse', + { 'message': string, + 'server': modifier_data }) + if 'nick' not in msg or 'channel' not in msg or 'arguments' not in msg: + return string + + try: + message = msg['arguments'].split(' ', 1)[1] + if message.startswith(':'): + message = message[1:] + except: + return string + + if weechat.info_get('irc_is_channel', '%s,%s' % (modifier_data, msg['channel'])) == '1': + name = msg['channel'] + else: + name = msg['nick'] + buffer_full_name = 'irc.%s.%s' % (modifier_data, name) + if urlserver_settings['buffer_short_name'] == 'on': + buffer_short_name = name + else: + buffer_short_name = buffer_full_name + urls_short = urlserver_update_urllist(buffer_full_name, buffer_short_name, None, msg['nick'], message, msg['nick']) + if urls_short: + if urlserver_settings['separators'] and len(urlserver_settings['separators']) == 3: + separator = ' %s ' % (urlserver_settings['separators'][1]) + urls_string = separator.join(urls_short) + urls_string = '%s %s %s' % (urlserver_settings['separators'][0], urls_string, urlserver_settings['separators'][2]) + else: + urls_string = ' | '.join(urls_short) + urls_string = '[ ' + urls_string + ' ]' + + if urlserver_settings['color_in_msg']: + urls_string = '\x03%s%s' % (urlserver_settings['color_in_msg'], urls_string) + string = "%s %s" % (string, urls_string) + + return string + def urlserver_config_cb(data, option, value): """Called when a script option is changed.""" global urlserver_settings @@ -681,8 +783,8 @@ ' See https://raw.github.com/FiXato/weechat_scripts/master/urlserver/sample.css\n' ' - don\'t like the built-in HTTP server to start automatically? Disable it:\n' ' /set plugins.var.python.urlserver.http_autostart "off"\n' - ' - have external port 80 forwarded to your internal server port? Remove :port with:\n' - ' /set plugins.var.python.urlserver.http_port_display "80"\n' + ' - have external port 80 or 443 (https) forwarded to your internal server port? Remove :port with:\n' + ' /set plugins.var.python.urlserver.http_port_display "80" or "443" respectively\n' '\n' 'Tip: use URL without key at the end to display list of all URLs in your browser.', 'start|restart|stop|status|clear', 'urlserver_cmd_cb', '') @@ -695,7 +797,11 @@ urlserver_read_urls() # catch URLs in buffers - weechat.hook_print("", "", "://", 1, "urlserver_print_cb", "") + weechat.hook_print('', '', '://', 1, 'urlserver_print_cb', '') + + # modify URLS in irc messages (for relay) + weechat.hook_modifier('irc_in2_privmsg', 'urlserver_modifier_irc_cb', '') + weechat.hook_modifier('irc_in2_notice', 'urlserver_modifier_irc_cb', '') # search buffer urlserver['buffer'] = weechat.buffer_search('python', SCRIPT_BUFFER) diff -Nru weechat-scripts-20130123/python/vimode.py weechat-scripts-20131007/python/vimode.py --- weechat-scripts-20130123/python/vimode.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/vimode.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,517 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013 Germain Z. +# +# 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 . +# + +# +# Description: +# An attempt to add a vi-like mode to WeeChat, which provides some common vi +# key bindings and commands, as well as normal/insert modes. +# +# Usage: +# To switch to Normal mode, press Ctrl + Space. The Escape key is reported as +# a modifier, so it can't be used for now. +# To switch back to Insert mode, you can use i/a/A (or cw/ce/...). +# To execute a command, simply precede it with a ':' while in normal mode, +# for example: ":h" or ":s/foo/bar". +# +# Current key bindings: +# j Scroll buffer up * (scrolls a few lines at a time) +# k Scroll buffer down * (same as above) +# w Forward to the beginning of word +# e Forward to the end of word +# b Backward to the beginning of word +# gg Go to top of buffer * (no counts) +# G Go to bottom of buffer +# h Move cursor left +# l Move cursor right +# 0 Go to beginning of line +# ^ Go to beginning of line * (doesn't take whitespace into +# consideration, behaves like '0') +# $ Go to end of line * (same as above) +# x Delete character at cursor +# dw Delete word +# db Delete previous word +# de Delete till end of word +# d^ Delete till beginning of line +# d$ Delete till end of line +# dd Delete line +# ce Delete till end of word, switch to insert mode +# cw Delete word, switch to insert mode +# cb Delete previous word, switch to insert mode +# c^ Delete till beginning of line, switch to insert mode +# c$ Delete till end of line, switch to insert mode +# dd Delete line, switch to insert mode +# / Launch WeeChat search mode +# Counts (e.g. 'd2w', '2G') are supported. However, key bindings marked with a +# '*' won't perform as intended for the time being. Explanation follows in +# parentheses. +# TODO: yy yw ye yb p, make 'e'/'w'/... return start/end positions to avoid +# redundancy and make them usable by multiple modifiers (e.g. 'de', 'dw') +# TODO (later): u U C-R r R % +# better search (/), add: n N ? +# TODO (even later): . +# +# Current commands: +# :h Help (/help) +# :set Set WeeChat config option (/set) +# :q Closes current buffer (/close) +# :qall Exits WeeChat (/exit) +# :w Saves settings (/save) +# :s/pattern/repl +# :s/pattern/repl/g Search/Replace, supports regex (check docs for the Python +# re module for more information). '&' in the replacement is +# also substituted by the pattern. If the 'g' flag isn't +# present, only the first match will be substituted. +# Escapes are not interpreted for repl (e.g. '\&'), and '/' +# isn't expected to be used/escaped anywhere in the command. +# TODO: Improve this. +# TODO: :! (probably using shell.py) +# :w saves buffer's contents to file +# :r puts file's content in input line/open in buffer? +# TODO: Display matching commands with (basic) help, like Penta/Vimp do. +# +# History: +# version 0.1: initial release +# version 0.2: added esc to switch to normal mode, various key bindings and +# commands. +# + +import weechat +import re +import time + + +SCRIPT_NAME = "vimode" +SCRIPT_AUTHOR = "GermainZ " +SCRIPT_VERSION = "0.2" +SCRIPT_LICENSE = "GPL3" +SCRIPT_DESC = ("An attempt to add a vi-like mode to WeeChat, which adds some" + " common vi key bindings and commands, as well as normal/insert" + " modes.") + +# Initialize variables: +input_line = '' # used to communicate between functions, when only passing a + # single string is allowed (e.g. for weechat.hook_timer). +cmd_text = '' # holds the text of the command line. +mode = "INSERT" # mode we start in (INSERT or COMMAND), insert by default. +pressed_keys = '' # holds any pressed keys, regardless of their type. +vi_buffer = '' # holds 'printable' pressed keys (e.g. arrow keys aren't added). +last_time = time.time() # used to check if pressed_keys and vi_buffer need to + #be reset. +num = r"[0-9]*" # simple regex to detect number of repeats in keystrokes such + # as "d2w" + +# Some common vi commands. +# Others may be present in exec_cmd: +vi_commands = {'h': "/help", 'qall': "/exit", 'q': "/close", 'w': "/save", + 'set': "/set"} + +# Common vi key bindings. A dict holds necessary values further down. +def key_G(repeat): + """Simulate vi's behavior for the G key.""" + if repeat > 0: + # This is necessary to prevent weird scroll jumps. + weechat.command('', "/window scroll_bottom") + weechat.command('', "/window scroll %s" % repeat) + else: + weechat.command('', "/window scroll_bottom") + +def key_dw(repeat, key="dw"): + """Simulate vi's behavior for dw or de.""" + buf = weechat.current_buffer() + input_line = weechat.buffer_get_string(buf, 'input') + cur = weechat.buffer_get_integer(buf, "input_pos") + input_line = list(input_line) + for i in range(max([1, repeat])): + done = False + found_letter = False + delete_word = True + one_timer = False + while done is False: + if cur >= len(input_line): + done = True + elif input_line[cur] != ' ' and delete_word is True: + found_letter = True + del input_line[cur] + elif input_line[cur] == ' ' and found_letter is False: + if key == "dw": + delete_word = False + del input_line[cur] + elif input_line[cur] == ' ' and found_letter is True: + delete_word = False + if key == "dw" or (one_timer is False and + cur < len(input_line) and + input_line[cur + 1] == ' ' + and i < max([1, repeat]) - 1): + one_timer = True + del input_line[cur] + else: + if i == max([1, repeat]) - 1: + cur += 1 + else: + del input_line[cur] + else: + done = True + input_line = ''.join(input_line) + weechat.buffer_set(buf, "input", input_line) + +def key_de(repeat): + """Simulate vi's behavior for the de key.""" + key_dw(repeat, "de") + +def key_w(repeat): + """Simulate vi's behavior for the w key.""" + buf = weechat.current_buffer() + for _ in range(max([1, repeat])): + input_line = weechat.buffer_get_string(buf, 'input') + cur = weechat.buffer_get_integer(buf, "input_pos") + weechat.command('', ("/input move_next_word\n/input move_next_word\n" + "/input move_previous_word")) + if len(input_line[cur:].split(' ')) == 1: + weechat.command('', "/input move_end_of_line") + +def key_cw(repeat): + """Simulate vi's behavior for the cw key.""" + key_dw(repeat) + set_mode("INSERT") + +def key_ce(repeat): + """Simulate vi's behavior for the ce key.""" + """Key ce.""" + key_de(repeat) + set_mode("INSERT") + +def key_cb(repeat): + """Simulate vi's behavior for the cb key.""" + for _ in range(max[1, repeat]): + weechat.command('', "/input move_previous_word") + set_mode("INSERT") + +def key_ccarret(repeat): + """Simulate vi's behavior for the c^ key.""" + for _ in range(max[1, repeat]): + weechat.command('', "/input delete_beginning_of_line") + set_mode("INSERT") + +def key_cdollar(repeat): + """Simulate vi's behavior for the c$ key.""" + for _ in range(max[1, repeat]): + weechat.command('', "/input delete_end_of_line") + set_mode("INSERT") + +def key_cd(repeat): + """Simulate vi's behavior for the cd key.""" + weechat.command('', "/input delete_line") + set_mode("INSERT") + +# Common vi key bindings. If the value is a string, it's assumed it's a WeeChat +# command, and a function otherwise. +vi_keys = {'j': "/window scroll_down", + 'k': "/window scroll_up", + 'G': key_G, + 'gg': "/window scroll_top", + 'h': "/input move_previous_char", + 'l': "/input move_next_char", + 'w': key_w, + 'e': ("/input move_next_char\n/input move_next_word\n" + "/input move_previous_char"), + 'b': "/input move_previous_word", + '^': "/input move_beginning_of_line", + '$': "/input move_end_of_line", + 'x': "/input delete_next_char", + 'dd': "/input delete_line", + 'd$': "/input delete_end_of_line", + 'd^': "/input delete_beginning_of_line", + 'dw': key_dw, + 'db': "/input delete_previous_word", + 'de': key_de, + 'cw': key_cw, + 'ce': key_ce, + 'cb': key_cb, + 'c^': key_ccarret, + 'c$': key_cdollar, + 'cd': key_cd, + '0': "/input move_beginning_of_line", + '/': "/input search_text"} + + +def set_mode(arg): + """Set the current mode and update the bar mode indicator.""" + global mode + mode = arg + weechat.bar_item_update("mode_indicator") + +def vi_buffer_cb(data, item, window): + """Return the content of the vi buffer (pressed keys on hold).""" + return vi_buffer + +def cmd_text_cb(data, item, window): + """Return the text of the command line.""" + return cmd_text + +def mode_indicator_cb(data, item, window): + """Return the current mode (INSERT/COMMAND).""" + return mode + +def exec_cmd(data, remaining_calls): + """Translate and execute our custom commands to WeeChat command, with + any passed arguments. + + input_line is set in key_pressed_cb and is used here to restore its value + if we want, along with any potential replacements that should be made (e.g. + for s/foo/bar type commands). + + """ + global input_line + data = list(data) + del data[0] + data = ''.join(data) + data = data.split(' ', 1) + cmd = data[0] + if len(data) == 2: + args = data[1] + else: + args = '' + if cmd in vi_commands: + weechat.command('', "%s %s" % (vi_commands[cmd], args)) + # s/foo/bar command + elif cmd.startswith("s/"): + pattern = cmd.split('/')[1] + repl = cmd.split('/')[2].replace('&', pattern) + flag = None + count = 1 + if len(cmd.split('/')) > 3: + flag = cmd.split('/')[3] + if flag == 'g': + count = 0 + buf = weechat.current_buffer() + input_line = re.sub(pattern, repl, input_line, count) + weechat.buffer_set(buf, "input", input_line) + else: + weechat.prnt('', "Command '%s' not found." % cmd) + return weechat.WEECHAT_RC_OK + +def input_set(data, remaining_calls): + """Set the input line's content.""" + buf = weechat.current_buffer() + weechat.buffer_set(buf, "input", data) + # move the cursor back to its position prior to setting the content + weechat.command('', "/input move_next_char") + return weechat.WEECHAT_RC_OK + +def input_rem_char(data, remaining_calls): + """Remove one character from the input buffer. + + If data is set to 'cursor', the character at the cursor will be removed. + Otherwise, data must be an integer and the character at that position will + be removed instead. + + """ + buf = weechat.current_buffer() + input_line = weechat.buffer_get_string(buf, 'input') + if data == "cursor": + data = weechat.buffer_get_integer(buf, "input_pos") + input_line = list(input_line) + try: + del input_line[int(data - 1)] + # Not sure why nothing is being detected in some cases from the first time + except IndexError: + weechat.hook_timer(1, 0, 1, "input_rem_char", "cursor") + return weechat.WEECHAT_RC_OK + input_line = ''.join(input_line) + weechat.buffer_set(buf, "input", input_line) + # move the cursor back to its position before removing our character + weechat.command('', "/input move_previous_char") + return weechat.WEECHAT_RC_OK + +def handle_esc(data, remaining_calls): + """Esc acts as a modifier and usually waits for another keypress. + + To circumvent that, simulate a keypress then remove what was inserted. + + """ + global cmd_text + weechat.command('', "/input insert %s" % data) + weechat.hook_signal_send("key_pressed", weechat.WEECHAT_HOOK_SIGNAL_STRING, + data) + if cmd_text == ":[": + cmd_text = ':' + return weechat.WEECHAT_RC_OK + +esc_pressed = False +def pressed_keys_check(data, remaining_calls): + """Check the pressed keys and changes modes or detects bound keys + accordingly. + + """ + global pressed_keys, mode, vi_buffer, esc_pressed + # If the last pressed key was Escape, this one will be detected as an arg + # as Escape acts like a modifier (pressing Esc, then pressing i is detected + # as pressing meta-i). We'll emulate it being pressed again, so that the + # user's input is actually processed normally. + if esc_pressed is True: + esc_pressed = False + weechat.hook_timer(50, 0, 1, "handle_esc", pressed_keys[-1]) + if mode == "INSERT": + # Ctrl + Space, or Escape + if pressed_keys == "@" or pressed_keys == "[": + set_mode("NORMAL") + if pressed_keys == "[": + esc_pressed = True + elif mode == "NORMAL": + # We strip all numbers and check if the the combo is recognized below, + # then extract the numbers, if any, and pass them as the repeat factor. + buffer_stripped = re.sub(num, '', vi_buffer) + if vi_buffer in ['i', 'a', 'A']: + set_mode("INSERT") + if vi_buffer == 'a': + weechat.command('', "/input move_next_char") + elif vi_buffer == 'A': + weechat.command('', "/input move_end_of_line") + # Quick way to detect repeats (e.g. d5w). This isn't perfect, as things + # like "5d2w1" are detected as "dw" repeated 521 times, but it should + # be alright as long as the user doesn't try to break it on purpose. + # Maximum number of repeats performed is 10000. + elif buffer_stripped in vi_keys: + repeat = ''.join(re.findall(num, vi_buffer)) + if len(repeat) > 0: + repeat = min([int(repeat), 10000]) + else: + repeat = 0 + if isinstance(vi_keys[buffer_stripped], str): + for _ in range(1 if repeat == 0 else repeat): + weechat.command('', vi_keys[re.sub(num, '', vi_buffer)]) + else: + vi_keys[buffer_stripped](repeat) + else: + return weechat.WEECHAT_RC_OK + clear_vi_buffers() + return weechat.WEECHAT_RC_OK + +def clear_vi_buffers(data=None, remaining_calls=None): + """Clear both pressed_keys and vi_buffer. + + If data is set to 'check_time', they'll only be cleared if enough time has + gone by since they've been last set. + This is useful as this function is called using a timer, so other keys + might've been pressed before the timer is activated. + + """ + global pressed_keys, vi_buffer + if data == "check_time" and time.time() < last_time + 1.0: + return weechat.WEECHAT_RC_OK + pressed_keys = '' + vi_buffer = '' + weechat.bar_item_update("vi_buffer") + return weechat.WEECHAT_RC_OK + +def is_printing(current, saved): + """Is the character a visible, printing character that would normally + show in the input box? + + Previously saved characters are taken into consideration as well for some + key combinations, such as the arrows, which are detected as three separate + events (^A[, [ and A/B/C/D). + The keys buffers will be cleared if the character isn't visible. + + """ + if current.startswith("") or saved.startswith(""): + weechat.hook_timer(50, 0, 1, "clear_vi_buffers", '') + return False + return True + +def key_pressed_cb(data, signal, signal_data): + """Handle key presses. + + Make sure inputted keys are removed from the input bar and added to the + appropriate keys buffers or to the command line if it's active, activate it + when needed, etc. + + """ + global pressed_keys, last_time, cmd_text, input_line, vi_buffer + if mode == "NORMAL": + # The character is a printing character, so we'll want to remove it + # so it doesn't add up to the normal input box. + if is_printing(signal_data, pressed_keys): + weechat.hook_timer(1, 0, 1, "input_rem_char", "cursor") + # It's a command! + if signal_data == ':': + cmd_text += ':' + # Command line is active, so we want to check for some special keys + # to modify (backspace/normal keys) or submit (Return key) our command. + elif cmd_text != '': + # Backspace key + if signal_data == "?": + buf = weechat.current_buffer() + input_line = weechat.buffer_get_string(buf, 'input') + # Remove the last character from our command line + cmd_text = list(cmd_text) + del cmd_text[-1] + cmd_text = ''.join(cmd_text) + # We can't actually eat these keystrokes, so simply removing + # the last character would result in the last two characters + # being removed (once by the backspace key, once by our script) + # Instead, we'll just set the input line in a millisecond to + # its original value, leaving it untouched. + weechat.hook_timer(1, 0, 1, "input_set", input_line) + # Return key + elif signal_data == "M": + buf = weechat.current_buffer() + # Clear the input line, therefore nullifying the effect of the + # Return key, then set it back a millisecond later. + # This leaves the input box untouched and allows us to execute + # the command filled in in our command line. + # We can only pass strings as data using hook_timer, so we'll + # use the global variable input_line in our exec_cmd function + # instead to reset the input box's value. + input_line = weechat.buffer_get_string(buf, 'input') + weechat.buffer_set(buf, "input", '') + weechat.hook_timer(1, 0, 1, "exec_cmd", cmd_text) + cmd_text = '' + # The key is a normal key, so just append it to our command line. + elif is_printing(signal_data, pressed_keys): + cmd_text += signal_data + # Show the command line when needed, hide it (and update vi_buffer since + # we'd be looking for keystrokes instead) otherwise. + if cmd_text != '': + weechat.command('', "/bar show vi_cmd") + weechat.bar_item_update("cmd_text") + else: + weechat.command('', "/bar hide vi_cmd") + if is_printing(signal_data, pressed_keys): + vi_buffer += signal_data + pressed_keys += signal_data + # Check for any matching bound keys. + weechat.hook_timer(1, 0, 1, "pressed_keys_check", '') + last_time = time.time() + # Clear the buffers after some time. + weechat.hook_timer(1000, 0, 1, "clear_vi_buffers", "check_time") + weechat.bar_item_update("vi_buffer") + return weechat.WEECHAT_RC_OK + + +weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, + SCRIPT_DESC, '', '') + +weechat.bar_item_new("mode_indicator", "mode_indicator_cb", '') +weechat.bar_item_new("cmd_text", "cmd_text_cb", '') +weechat.bar_item_new("vi_buffer", "vi_buffer_cb", '') +vi_cmd = weechat.bar_new("vi_cmd", "off", "0", "root", '', "bottom", + "vertical", "vertical", "0", "0", "default", + "default", "default", "0", "cmd_text") +weechat.hook_signal("key_pressed", "key_pressed_cb", '') + diff -Nru weechat-scripts-20130123/python/weeget.py weechat-scripts-20131007/python/weeget.py --- weechat-scripts-20130123/python/weeget.py 2013-01-23 19:00:06.000000000 +0000 +++ weechat-scripts-20131007/python/weeget.py 2013-10-07 12:14:39.000000000 +0000 @@ -20,8 +20,13 @@ # WeeChat scripts manager. # (this script requires WeeChat >= 0.3.0 and python >= 2.6) # +# IMPORTANT: this script is obsolete since WeeChat 0.3.9, it is replaced +# by command /script (script plugin). +# # History: # +# 2013-03-06, Sebastien Helleu : +# version 2.0: display "obsolete script" warning on WeeChat >= 0.3.9 # 2012-10-08, Sebastien Helleu : # version 1.9: remove obsolete database field "desc_fr" # (it was causing error with /weeget list xxx) @@ -71,7 +76,7 @@ SCRIPT_NAME = "weeget" SCRIPT_AUTHOR = "Sebastien Helleu " -SCRIPT_VERSION = "1.9" +SCRIPT_VERSION = "2.0" SCRIPT_LICENSE = "GPL3" SCRIPT_DESC = "WeeChat scripts manager" @@ -972,6 +977,11 @@ "wg_completion_scripts_installed_cb", "") weechat.hook_completion("weeget_scripts_tags", "tags of scripts in repository", "wg_completion_scripts_tags_cb", "") + version = weechat.info_get("version_number", "") or 0 + if int(version) >= 0x00030900: + weechat.prnt("", "%sWARNING: the script weeget.py is obsolete since WeeChat 0.3.9 " + "(it is replaced by command /script)" % weechat.prefix("error")) + weechat.prnt("", "%sTo uninstall weeget.py: /weeget remove weeget.py" % weechat.prefix("error")) # ==================================[ end ]=================================== diff -Nru weechat-scripts-20130123/python/weetweet.py weechat-scripts-20131007/python/weetweet.py --- weechat-scripts-20130123/python/weetweet.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/weetweet.py 2013-10-07 12:14:50.000000000 +0000 @@ -0,0 +1,1097 @@ +# +# Copyright (c) 2013 by DarkDefender +# File bugs here: https://github.com/DarkDefender/weetweet + +# 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 . +# + +import sys +import ast +import re +import os +import tempfile +import time +import calendar +import socket + +# TODO: +# Add desc for script options +# Replace the thread call, old api will be blocked soon + +# This twitter plugin can be extended even more. Just look at the twitter api +# doc here: https://dev.twitter.com/docs/api/1.1 + +# Thanks to ttytter for interface ideas! +# http://www.floodgap.com/software/ttytter/ + +# I've borrowed some ideas, functions for ainmosni and his twitter plugin +# https://github.com/ainmosni/weetwit + +weechat_call = True +import_ok = True + +try: + import weechat +except: + #import html parser so we can convert html strings to plain text + try: + import html.parser + except: + print("You need to have python3 installed to run this script!") + exit(0) + weechat_call = False + +try: + #Import python twitter lib + from twitter import * +except: + import_ok = False + +# These two keys is what identifies this twitter client as "weechat twitter" +# If you want to change it you can register your own keys at: +# https://dev.twitter.com/apps/new + +CONSUMER_SECRET = 'ivx3oxxkSOAOofRuhmGXQK4nkLFNXD94wbJiRUBhN1g' +CONSUMER_KEY = 'NVkYe8DAeaw6YRcjw662ZQ' + +script_options = { + "oauth_token" : "", + "oauth_secret" : "", + "auth_complete" : False, + "screen_name" : "", + "last_id" : "", + "print_id" : True, + "alt_rt_style" : False, + "home_replies" : False, + "tweet_nicks" : True, +} + +tweet_dict = {'cur_index': "a0"} +#Mega command dict +command_dict = dict(thread="th",user="u",replies="r",view_tweet="v", + retweet="rt",delete="d",tweet="t",reply="re",new_tweets="new", + follow_user="follow",unfollow_user="unfollow",following="f", + followers="fo",about="a",block="b",unblock="ub", + blocked_users="blocks",favorite="fav",unfavorite="unfav", + favorites="favs", rate_limits="limits",home_timeline="home", + clear_nicks="cnicks",clear_buffer="clear",create_stream="stream") +desc_dict = dict(thread=", Shows the conversation of the tweet", + user="[||], Request user timeline, " + + "if is given it will get tweets older than , " + + " is how many tweets to get, valid number is 1-200", + replies="[||],Get any replies/mentions of you " + + "if is given it will get tweets older than , " + + " is how many tweets to get, valid number is 1-200", + view_tweet=", View/get tweet with ", + retweet=", Retweet ", + delete=", Delete tweet . You can only delete your own tweets...", + tweet="Tweet the text following this command", + reply=", reply to . You need to have @ " + + "of the user that you reply to in the tweet text. If this is not " + + "the case this will be treated like a normal tweet instead.", + new_tweets="Get new tweets from your home_timeline. This is only " + + "useful if you have disabled the auto updater", + follow_user=", Add user to people you follow", + unfollow_user=", Remove user for people you follow", + following="[|||], Show 'friends' of or " + + "if no user were given show the people you follow. If not all " + + "followers were printed supply the of the last list to get " + + "the new batch of nicks", + followers="[|||], Who followes or " + + "if no user were given show your follower. If not all " + + "followers were printed supply the of the last list to get " + + "the new batch of nicks", + about=", Print info about ", + block=", Block ", + unblock=", Unblock ", + blocked_users="Print a list of users you have currently blocked", + favorite=", Add tweet to you favorites", + unfavorite=", Remove tweet from yout favorites", + favorites="[|][||], Request favs, " + + "if is not given get your own favs. " + + "If is given it will get tweets older than , " + + " is how many tweets to get, valid number is 1-200", + rate_limits="[|], get the current status of the twitter " + + "api limits. It prints how much you have left/used. " + + " if is supplied it will only get/print that sub_group.", + home_timeline="[||],Get tweets from you home " + + "timeline" + + "if is given it will get tweets older than , " + + " is how many tweets to get, valid number is 1-200", + clear_nicks="Clear nicks from the 'Tweet_parse' nick group. "+ + "These nicks are parsed from recived tweets, it can get " + + "messy at times...", + clear_buffer="Clear the twitter buffer of text "+ + "same as '/buffer clear'", + create_stream="Create a twitter stream with the following filter "+ + "options: & . Note that they must be " + + "seperated by a ' & '. To only use keywords just have ' & ' in the "+ + "begininng.\n NOTE: you can only have one stream at a time because "+ + "twitter will IP ban you if you repeatedly request more than one "+ + "stream.") + +SCRIPT_NAME = "weetweet" +SCRIPT_FILE_PATH = os.path.abspath(__file__) + +twit_buf = "" +timer_hook = "" +sock_hooks = {} +proc_hooks = {} +sock_fd_dict = {} +tweet_nicks_group = {} +friends_nicks_group = {} + +html_escape_table = { + '"': """, + "'": "'", + } + +def html_escape(text): + """Produce entities within text.""" + return "".join(html_escape_table.get(c,c) for c in text) + +def dict_tweet(tweet_id): + cur_index = tweet_dict['cur_index'] + if not tweet_id in tweet_dict.values(): + if cur_index == 'z9': + cur_index = 'a0' + + if cur_index[1] == '9': + cur_index = chr(ord(cur_index[0]) + 1) + '0' + else: + cur_index = cur_index[0] + chr(ord(cur_index[1]) + 1) + + tweet_dict[cur_index] = tweet_id + tweet_dict['cur_index'] = cur_index + return cur_index + else: + for index, t_id in tweet_dict.items(): + if t_id == tweet_id: + return index + + +def read_config(): + for item in script_options: + script_options[item] = weechat.config_string(weechat.config_get("plugins.var.python."+SCRIPT_NAME+"." + item)) + for item in ["auth_complete","print_id","alt_rt_style","home_replies","tweet_nicks"]: + #Convert to bool + script_options[item] = weechat.config_string_to_boolean(script_options[item]) + +def config_cb(data, option, value): + """Callback called when a script option is changed.""" + # for example, read all script options to script variables... + # ... + read_config() + return weechat.WEECHAT_RC_OK + +def add_to_nicklist(buf, nick, group=""): + """Add nick to the nicklist.""" + if group == "": + group = friends_nicks_group[buf] + weechat.nicklist_add_nick(buf, group, nick, 'bar_fg', '', '', 1) + +def remove_from_nicklist(buf, nick, group=""): + """Remove nick from the nicklist.""" + if group == "": + group = friends_nicks_group[buf] + nick_ptr = weechat.nicklist_search_nick(buf, group, nick) + weechat.nicklist_remove_nick(buf, nick_ptr) + +def parse_for_nicks(text,buffer): + #Parse text for twitter nicks and add them to nicklist + regex = re.compile(r'@([A-Za-z0-9_]+)') + reset = weechat.color('reset') + for word in text.split(): + match = re.search(regex,word) + if str(type(match)) == "": + nick = word[match.start(1):match.end(0)] + add_to_nicklist(buffer,nick,tweet_nicks_group[buffer]) + +def print_tweet_data(buffer,tweets,data): + + cur_date = time.strftime("%Y-%m-%d", time.localtime()) + + for message in tweets: + nick = message[1] + text = message[3] + reply_id = "" + if script_options['tweet_nicks']: + parse_for_nicks(text,buffer) + add_to_nicklist(buffer,nick,tweet_nicks_group[buffer]) + + if script_options['print_id']: + t_id = weechat.color('reset') + ' ' + dict_tweet(message[2]) + else: + t_id = '' + + if len(message) == 5: + #This is a reply to a tweet + arrow_col = weechat.color('chat_prefix_suffix') + reset_col = weechat.color('reset') + reply_id = arrow_col + "<" + reset_col + dict_tweet(message[4]) + arrow_col + "> " + reset_col + temp_text = text + text = reply_id + reply_id = temp_text + + mes_date = time.strftime("%Y-%m-%d", time.localtime(message[0])) + if cur_date != mes_date: + cur_date = mes_date + weechat.prnt(buffer, "\t\tDate: " + cur_date) + + weechat.prnt_date_tags(buffer, message[0], "notify_message", + "%s%s\t%s%s" % (nick, t_id, text,reply_id)) + if data == "id": + try: + if script_options['last_id'] < tweets[-1][2]: + script_options['last_id'] = tweets[-1][2] + # Save last id + weechat.config_set_plugin("last_id",script_options["last_id"]) + except: + pass + +def trim_tweet_data(tweet_data, screen_name, alt_rt_style): + # Because of the huge amount of data, we need to cut down on most of it because we only really want + # a small subset of it. This also prevents the output buffer from overflowing when fetching many tweets + # at once. + + h = html.parser.HTMLParser() + + output = [] + for message in tweet_data: + if alt_rt_style and message.get('retweeted_status'): + if message['user']['screen_name'] == screen_name: + #escape highlighting + message['user']['screen_name'] = "" + message['text'] = message['retweeted_status']['text'] + " (retweeted by " + message['user']['screen_name'] + ")" + message['user'] = message['retweeted_status']['user'] + mes_list =[calendar.timegm(time.strptime(message['created_at'],'%a %b %d %H:%M:%S +0000 %Y')), + message['user']['screen_name'], + message['id_str'], + h.unescape(message['text'])] + if message["in_reply_to_status_id_str"] != None: + mes_list.append(message["in_reply_to_status_id_str"]) + + output.append(mes_list) + + output.reverse() + return output + +def twitter_stream_cb(buffer,fd): + #accept connection + server = sock_fd_dict[sock_fd_dict[fd]] + conn, addr = server.accept() + error = False + tweet = "" + data = True + while data: + try: + data = conn.recv(1024).decode('utf-8') + tweet += data + except: + break + + try: + tweet = ast.literal_eval(tweet) + #weechat.prnt(buffer, "recv streamed tweet" + tweet) + except: + weechat.prnt(buffer, "Error resv stream message") + return weechat.WEECHAT_RC_OK + if buffer == twit_buf: + #Update last recv id + print_tweet_data(buffer,tweet,"id") + else: + print_tweet_data(buffer,tweet,"") + conn.close() + return weechat.WEECHAT_RC_OK + +def twitter_stream(cmd_args): + if len(cmd_args) < 5: + return "Invalid stream command" + if not os.path.exists(cmd_args[4]): + return "The socket file doesn't exist! " + cmd_args[4] + + oauth_token = cmd_args[1] + oauth_secret= cmd_args[2] + + try: + if cmd_args[-1][0] == "{": + option_dict = ast.literal_eval(cmd_args[-1]) + cmd_args.pop(-1) + no_home_replies = option_dict['home_replies'] + alt_rt_style = option_dict['alt_rt_style'] + screen_name = option_dict['screen_name'] + name = option_dict['name'] + stream_args = option_dict['stream_args'] + except: + return "Error starting stream, no option arguments" + + def connect(): + client = socket.socket( socket.AF_UNIX, socket.SOCK_STREAM ) + client.connect(cmd_args[4]) + #Don't block, timeout if no data is present + client.setblocking(0) + return client + + if name == "twitter": + #home timeline stream + stream = TwitterStream(auth=OAuth( + oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET), + domain="userstream.twitter.com") + tweet_iter = stream.user() + else: + h = html.parser.HTMLParser() + args = stream_args.split(" & ") + stream = TwitterStream(auth=OAuth( + oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET)) + + twitter = Twitter(auth=OAuth( + oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET)) + + if args[0] != "": + follow = ",".join(h.unescape(args[0]).split()) + twitter_data = twitter.users.lookup(screen_name=follow) + follow_ids = "" + for user in twitter_data: + follow_ids += user['id_str'] + "," + follow_ids = follow_ids[:-1] + if len(args) == 2 and args[1] != "": + track = ",".join(h.unescape(args[1]).split()) + tweet_iter = stream.statuses.filter(track=track,follow=follow_ids) + else: + tweet_iter = stream.statuses.filter(follow=follow_ids) + else: + track = ",".join(h.unescape(args[1]).split()) + tweet_iter = stream.statuses.filter(track=track) + + # Iterate over the stream. + for tweet in tweet_iter: + # You must test that your tweet has text. It might be a delete + # or data message. + if tweet.get('text'): + tweet = trim_tweet_data([tweet],screen_name,alt_rt_style) + client = connect() + client.sendall(bytes(str(tweet),"utf-8")) + client.close() + + return "Stream shut down" + +def stream_close_cb(name,buffer): + global sock_fd_dict + global proc_hooks + weechat.unhook(sock_hooks[name]) + weechat.unhook(proc_hooks[name]) + #remove fd key + for key, value in sock_fd_dict.items(): + if value == name: + sock_fd_dict.pop(key, None) + break + sock_fd_dict[name].close() + proc_hooks.pop(name,None) + sock_fd_dict.pop(name, None) + return weechat.WEECHAT_RC_OK + +def create_stream(name, args = ""): + global sock_fd_dict + global proc_hooks + global sock_hooks + + if proc_hooks.get(name): + return "Stream has already been created, close it before trying to open a new one" + + #Check if buffer exists + buffer = weechat.buffer_search("python", name) + if buffer == "": + buffer = weechat.buffer_new(name, "buffer_input_cb", name, "stream_close_cb", name) + setup_buffer(buffer) + + if not sock_fd_dict.get(name): + file_name = tempfile.gettempdir() + "/we_tw_" + name + if os.path.exists(file_name): + os.remove(file_name) + + server = socket.socket( socket.AF_UNIX, socket.SOCK_STREAM ) + server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + server.bind(file_name) + #Don't block, timeout if no data is present + server.setblocking(0) + server.listen(1) + file_fd = server.fileno() + sock_fd_dict[str(file_fd)] = name + sock_fd_dict[name] = server + sock_hooks[name] = weechat.hook_fd(file_fd, 1, 0, 0, "twitter_stream_cb", buffer) + + options = dict(screen_name = script_options['screen_name'], name = name, + alt_rt_style = int(script_options['alt_rt_style']), + home_replies = int(script_options['home_replies']), + stream_args = args) + + proc_hooks[name] = weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + "stream " + file_name + ' "' + str(options) + '"', 0 , "my_process_cb", str([buffer,""])) + return "Started stream" + +def my_process_cb(data, command, rc, out, err): + + if rc == weechat.WEECHAT_HOOK_PROCESS_ERROR: + weechat.prnt("", "Error with command '%s'" % + command.replace(script_options["oauth_token"],"").replace(script_options["oauth_secret"],"")) + return weechat.WEECHAT_RC_OK + + data = ast.literal_eval(data) + buffer = data[0] + end_mes = data[1] + + if out != "": + if out[0] != "[" and out[0] != "{": + #If message is just a string print it + weechat.prnt(buffer, "%s%s" % (weechat.prefix("network"), out)) + return weechat.WEECHAT_RC_OK + process_output = ast.literal_eval(out) + #List message + if len(end_mes) >= 1 and end_mes[0] == "L": + if isinstance(process_output[-1], int): + t_id = dict_tweet(str(process_output[-1])) + "\t" + process_output = process_output[:-1] + more = " ..." + else: + t_id = weechat.prefix("network") + more = "" + + for nick in process_output: + if end_mes == "LYFollowing": + add_to_nicklist(buffer,nick) + elif script_options['tweet_nicks']: + add_to_nicklist(buffer,nick,tweet_nicks_group[buffer]) + weechat.prnt_date_tags(buffer, 0, "no_highlight", + "%s%s: %s%s" % (t_id, end_mes[1:], process_output, more)) + return weechat.WEECHAT_RC_OK + + if end_mes == "About": + weechat.prnt(buffer, "Nick: %s | Name: %s | Protected: %s" % (process_output['screen_name'], + process_output['name'], + process_output['protected'])) + weechat.prnt(buffer, "Description: %s" % process_output['description']) + weechat.prnt(buffer, "Location: %s | Time zone: %s" % (process_output['location'], process_output['time_zone'])) + weechat.prnt(buffer, "Created at: %s | Verified user: %s" % (process_output['created_at'], process_output['verified'])) + weechat.prnt(buffer, "Following: %s | Followers: %s | Favourites: %s | Tweets: %s" % (process_output['friends_count'], + process_output['followers_count'], + process_output['favourites_count'], + process_output['statuses_count'])) + weechat.prnt(buffer, "Are you currently following this person: %s" % (process_output['following'])) + return weechat.WEECHAT_RC_OK + + print_tweet_data(buffer,process_output,end_mes) + + if end_mes != "id" and end_mes != "": + weechat.prnt(buffer, "%s%s" % (weechat.prefix("network"), end_mes)) + if err != "": + weechat.prnt("", "stderr: %s" % err) + return weechat.WEECHAT_RC_OK + +def get_twitter_data(cmd_args): + # Read the oauth token and auth with the twitter api. + # Return the requested tweets + no_home_replies = True + alt_rt_style = False + screen_name = "" + + h = html.parser.HTMLParser() + + try: + if cmd_args[-1][0] == "[": + option_list = ast.literal_eval(cmd_args[-1]) + cmd_args.pop(-1) + if "home_replies" in option_list: + no_home_replies = False + if "alt_rt_style" in option_list: + alt_rt_style = True + screen_name = option_list[0] + except: + pass + + if len(cmd_args) < 4: + return "Invalid command" + + oauth_token = cmd_args[1] + oauth_secret= cmd_args[2] + + if cmd_args[3] == "auth": + twitter = Twitter( + auth=OAuth(oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET), + format='', api_version=None) + if len(cmd_args) == 5: + #pin + return twitter.oauth.access_token(oauth_verifier=cmd_args[4]) + else: + return twitter.oauth.request_token() + try: + if len(cmd_args) == 5 and cmd_args[3] == 'th': + # use the old api to get the thread from a tweet + # NOTE This is unoffical and might stop working at any moment + twitter = Twitter( + auth=OAuth( + oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET), + secure=True, + api_version='1', + domain='api.twitter.com') + tweet_data = twitter.related_results.show._(cmd_args[4])() + #convert to new api data type + new_data = [] + for data in tweet_data[0]['results']: + new_data.append(data['value']) + + tweet_data = new_data + tweet_data.reverse() + else: + twitter = Twitter(auth=OAuth( + oauth_token, oauth_secret, CONSUMER_KEY, CONSUMER_SECRET)) + + if cmd_args[3] == "settings": + #this only gets called from within weechat + return twitter.account.settings()['screen_name'] + elif cmd_args[3] == "u": + kwargs = dict(count=20, screen_name=cmd_args[4]) + if len(cmd_args) == 7: + kwargs['count'] = int(cmd_args[6]) + kwargs['max_id'] = cmd_args[5] + elif len(cmd_args) == 6: + if int(cmd_args[5]) <= 200: + kwargs['count'] = int(cmd_args[5]) + else: + kwargs['max_id'] = cmd_args[5] + tweet_data = twitter.statuses.user_timeline(**kwargs) + elif cmd_args[3] == "r": + if len(cmd_args) == 6: + kwargs = dict(count=int(cmd_args[5]), max_id=cmd_args[4]) + tweet_data = twitter.statuses.mentions_timeline(**kwargs) + elif len(cmd_args) == 5: + if int(cmd_args[4]) <= 200: + tweet_data = twitter.statuses.mentions_timeline(count=int(cmd_args[4])) + else: + tweet_data = twitter.statuses.mentions_timeline(max_id=cmd_args[4]) + else: + tweet_data = twitter.statuses.mentions_timeline() + elif cmd_args[3] == "v": + tweet_data = [twitter.statuses.show._(cmd_args[4])()] + elif cmd_args[3] == "rt": + tweet_data = [twitter.statuses.retweet._(cmd_args[4])()] + #The home stream prints you messages as well... + tweet_data = [] + elif cmd_args[3] == "d": + #deletes tweet made by the user _(...) converts the id string to a call + #returns the tweet that was deleted (not a list(dict) just a dict) + #make it into a list so we don't have to write special cases for this + tweet_data = [twitter.statuses.destroy._(cmd_args[4])()] + elif cmd_args[3] == "t": + #returns the tweet that was sent (not a list(dict) just a dict) + #make it into a list so we don't have to write special cases for this + tweet_data = [twitter.statuses.update(status=h.unescape(cmd_args[4]))] + #The home stream prints you messages as well... + tweet_data = [] + elif cmd_args[3] == "re": + tweet_data = [twitter.statuses.update(status=h.unescape(cmd_args[5]), + in_reply_to_status_id=cmd_args[4])] + #The home stream prints you messages as well... + tweet_data = [] + elif cmd_args[3] == "new": + tweet_data = twitter.statuses.home_timeline(since_id = cmd_args[4], count=200, exclude_replies = no_home_replies) + elif cmd_args[3] == "follow": + tweet_data = [] + twitter.friendships.create(screen_name = cmd_args[4]) + elif cmd_args[3] == "unfollow": + tweet_data = [] + twitter.friendships.destroy(screen_name = cmd_args[4]) + elif cmd_args[3] == "f" or cmd_args[3] == "fo": + if len(cmd_args) == 6: + kwargs = dict(screen_name = cmd_args[4], stringify_ids = True, cursor = int(cmd_args[5]), count = 250) + else: + kwargs = dict(screen_name = cmd_args[4], stringify_ids = True, cursor = -1, count = 250) + if cmd_args[3] == "f": + tweet_data = twitter.friends.ids(**kwargs) + else: + tweet_data = twitter.followers.ids(**kwargs) + kwargs['cursor'] = tweet_data['next_cursor'] + friend_ids = tweet_data['ids'] + friend_list = list() + + while len(friend_ids) > 100: + tweet_data = twitter.users.lookup(user_id=",".join(friend_ids[:100])) + friend_ids = friend_ids[100:] + for user in tweet_data: + friend_list.append(user['screen_name']) + tweet_data = twitter.users.lookup(user_id=",".join(friend_ids)) + for user in tweet_data: + friend_list.append(user['screen_name']) + + if kwargs['cursor'] != 0: + friend_list.append(kwargs['cursor']) + return friend_list + elif cmd_args[3] == "a": + return twitter.users.show(screen_name = cmd_args[4]) + elif cmd_args[3] == "b": + tweet_data = [] + twitter.blocks.create(screen_name = cmd_args[4]) + elif cmd_args[3] == "ub": + tweet_data = [] + twitter.blocks.destroy(screen_name = cmd_args[4]) + elif cmd_args[3] == "blocks": + tweet_data = twitter.blocks.list(skip_status = True) + block_list = list() + for user in tweet_data['users']: + block_list.append(user['screen_name']) + return block_list + elif cmd_args[3] == "fav": + tweet_data = [twitter.favorites.create(_id=cmd_args[4])] + elif cmd_args[3] == "unfav": + tweet_data = [twitter.favorites.destroy(_id=cmd_args[4])] + elif cmd_args[3] == "favs": + if len(cmd_args) >= 5: + kwargs = dict() + if not cmd_args[4].isdigit(): + kwargs['screen_name'] = cmd_args[4] + cmd_args.pop(4) + if len(cmd_args) == 5: + if int(cmd_args[4]) <= 200: + kwargs['count'] = int(cmd_args[4]) + else: + kwargs['max_id'] = cmd_args[4] + elif len(cmd_args) == 6: + kwargs['count'] = int(cmd_args[5]) + kwargs['max_id'] = cmd_args[4] + tweet_data = twitter.favorites.list(**kwargs) + else: + tweet_data = twitter.favorites.list() + elif cmd_args[3] == "limits": + output = "" + if len(cmd_args) >= 5: + tweet_data = twitter.application.rate_limit_status(resources=",".join(cmd_args[4:])) + else: + tweet_data = twitter.application.rate_limit_status() + for res in tweet_data['resources']: + output += res + ":\n" + for sub_res in tweet_data['resources'][res]: + output += " " + sub_res[len(res)+2:] + ":\n" + output += " " + 'reset' + ": " + time.strftime('%Y-%m-%d %H:%M:%S', + time.localtime(tweet_data['resources'][res][sub_res]['reset'])) + "\n" + output += " " + 'limit' + ": " + str(tweet_data['resources'][res][sub_res]['limit']) + "\n" + output += " " + 'remaining' + ": " + str(tweet_data['resources'][res][sub_res]['remaining']) + "\n" + return output + elif cmd_args[3] == "home": + if len(cmd_args) == 6: + kwargs = dict(count=int(cmd_args[5]), max_id=cmd_args[4], exclude_replies = no_home_replies) + tweet_data = twitter.statuses.home_timeline(**kwargs) + elif len(cmd_args) == 5: + if int(cmd_args[4]) <= 200: + tweet_data = twitter.statuses.home_timeline(count=int(cmd_args[4]), exclude_replies = no_home_replies) + else: + tweet_data = twitter.statuses.home_timeline(max_id=cmd_args[4], exclude_replies = no_home_replies) + else: + tweet_data = twitter.statuses.home_timeline(exclude_replies = no_home_replies) + else: + return "Invalid command: " + cmd_args[3] + except: + return "Unexpected error in get_twitter_data:%s\n Call: %s" % (sys.exc_info(), cmd_args[3]) + + return trim_tweet_data(tweet_data,screen_name,alt_rt_style) + +# callback for data received in input +def buffer_input_cb(data, buffer, input_data): + # ... + end_message = "" + options = [script_options['screen_name']] + if script_options['alt_rt_style']: + options.append("alt_rt_style") + if script_options['home_replies']: + options.append("home_replies") + + if input_data[0] == ':': + if data != "silent": + weechat.prnt_date_tags(buffer, 0, "no_highlight", input_data) + input_args = input_data.split() + command = input_args[0][1:] + if command_dict.get(command): + input_data = input_data.replace(command,command_dict[command],1) + command = command_dict[command] + if command == 'd' and tweet_dict.get(input_args[1]): + input_data = 'd ' + tweet_dict[input_args[1]] + weechat.prnt(buffer, "%sYou deleted the following tweet:" % weechat.prefix("network")) + elif command == 'v' and tweet_dict.get(input_args[1]): + input_data = 'v ' + tweet_dict[input_args[1]] + end_message = "Done" + elif command == 'rt' and tweet_dict.get(input_args[1]): + end_message = "id" + input_data = 'rt ' + tweet_dict[input_args[1]] + elif command == 're' and tweet_dict.get(input_args[1]): + end_message = "id" + input_data = 're ' + tweet_dict[input_args[1]] + " '" + html_escape(input_data[6:]) + "'" + elif command == 'th' and tweet_dict.get(input_args[1]): + weechat.prnt(buffer, "%sThread of the following tweet id: %s" % (weechat.prefix("network"), input_args[1])) + input_data = 'th ' + tweet_dict[input_args[1]] + input_data[6:] + end_message = "End of thread" + elif command == 'new': + end_message = "id" + if script_options['last_id'] != "": + input_data = 'new ' + script_options['last_id'] + else: + input_data = 'home' + elif command == 'home' or command == 'r' or (command == 'favs' and len(input_args) >= 2 and input_args[1].isdigit()): + input_data = command + if len(input_args) == 3 and tweet_dict.get(input_args[1]) and input_args[2].isdigit(): + num = int(input_args[2]) + # 200 tweets is the max request limit + if num <= 200 and num > 0: + input_data += " " + tweet_dict[input_args[1]] + " " + input_args[2] + else: + input_data += " " + tweet_dict[input_args[1]] + elif len(input_args) == 2: + if tweet_dict.get(input_args[1]): + input_data += " " + tweet_dict[input_args[1]] + elif input_args[1].isdigit(): + num = int(input_args[1]) + # 200 tweets is the max request limit + if num <= 200 and num > 0: + input_data += " " + input_args[1] + end_message = "Done" + elif command == 'u' or (command == 'favs' and len(input_args) >= 3): + input_data = " ".join(input_args[:2])[1:] + if len(input_args) == 4 and tweet_dict.get(input_args[2]) and input_args[3].isdigit(): + num = int(input_args[3]) + # 200 tweets is the max request limit + if num <= 200 and num > 0: + input_data += " " + tweet_dict[input_args[2]] + " " + input_args[3] + else: + input_data += " " + tweet_dict[input_args[2]] + elif len(input_args) == 3: + if tweet_dict.get(input_args[2]): + input_data += " " + tweet_dict[input_args[2]] + elif input_args[2].isdigit(): + num = int(input_args[2]) + # 200 tweets is the max request limit + if num <= 200 and num > 0: + input_data += " " + input_args[2] + end_message = "Done" + elif command == 'auth': + if len(input_args) == 2: + oauth_dance(buffer,input_args[1]) + else: + oauth_dance(buffer) + return weechat.WEECHAT_RC_OK + elif command == 'f' or command == 'fo': + #L because we are returning a list to be printed later on + end_message = "L" + if len(input_args) == 3 and tweet_dict.get(input_args[2]): + input_data = command + " " + input_args[1] + " " + tweet_dict[input_args[2]] + elif len(input_args) == 2: + if tweet_dict.get(input_args[1]): + input_data = command + " " + script_options['screen_name'] + " " + tweet_dict[input_args[1]] + #Your list, not any other users + end_message += "Y" + else: + input_data = input_data[1:] + else: + input_data = command + " " + script_options['screen_name'] + end_message += "Y" + if command == 'f': + end_message += "Following" + else: + end_message += "Followers" + elif command == 'a': + input_data = input_data[1:] + end_message = "About" + elif command == 'blocks': + input_data = input_data[1:] + end_message = "LBlock list" + elif command == 'fav' and tweet_dict.get(input_args[1]): + input_data = 'fav ' + tweet_dict[input_args[1]] + weechat.prnt(buffer, "%sYou fave'd the following tweet:" % weechat.prefix("network")) + elif command == 'unfav' and tweet_dict.get(input_args[1]): + input_data = 'unfav ' + tweet_dict[input_args[1]] + weechat.prnt(buffer, "%sYou unfave'd the following tweet:" % weechat.prefix("network")) + elif command == 'cnicks': + global tweet_nicks_group + if tweet_nicks_group[buffer] != "": + weechat.nicklist_remove_group(buffer, tweet_nicks_group[buffer]) + tweet_nicks_group[buffer] = "" + tweet_nicks_group[buffer] = weechat.nicklist_add_group(buffer, "", "Tweet_parse", + "weechat.color.nicklist_group", 1) + return weechat.WEECHAT_RC_OK + elif command == 'help': + weechat.command(buffer,"/help twitter") + weechat.prnt(buffer, "Exec command /help twitter, check your root buffer") + return weechat.WEECHAT_RC_OK + elif command == 'clear': + weechat.command(buffer,"/buffer clear") + return weechat.WEECHAT_RC_OK + elif command == 'stream': + args = html_escape(input_data[7:]) + weechat.prnt(buffer,create_stream("t_stream",args)) + return weechat.WEECHAT_RC_OK + else: + input_data = input_data[1:] + end_message = "Done" + else: + end_message = "id" + #esacpe special chars when printing to commandline + input_data = 't ' + "'" + html_escape(input_data) + "'" + #input_data = 't ' + "'" + html.escape(input_data) + "'" + + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + input_data + " " + '"' + str(options) + '"', 10 * 1000, "my_process_cb", str([buffer,end_message])) + return weechat.WEECHAT_RC_OK + +def my_command_cb(data, buffer, args): + # ... + + buffer_input_cb(data, twit_buf, ":"+args) + + return weechat.WEECHAT_RC_OK + +def hook_commands_and_completions(): + compl_list = [] + com_list = [] + desc_list = [] + for command in sorted(command_dict): + compl_list.append(command) + com_list.append(command + weechat.color("*red") + " or " + + weechat.color('reset') + command_dict[command] + "\n") + desc_list.append(weechat.color("chat_nick_other") + command + ": \n" + desc_dict[command]) + weechat.hook_command("twitter", "Command to interact with the twitter api/plugin", + " | ".join(com_list), + "You can type all of these command in the twitter buffer if you add a ':' before the command, IE:\n" + ":limits\n\n" + "If you don't type a command in the twitter buffer you will tweet that instead,\n" + "text after 140 chars will turn red to let you know were twitter will cut off your tweet.\n\n" + + weechat.color("*red") + "NOTE:\n" + "There are limits on how many twitter api calls you can do, some calls are _quite_ restricted.\n" + "So if you get HTML errors from the twitter lib you probably exceeded the limit\n" + "you can check out your limits with the rate_limits/limits command.\n" + "_Most_ commands in this plugin only uses one call. If you want to check old tweets\n" + "in your home timeline it's better to request many tweets in one go.\n" + "That way you don't have to request new tweets as often to go further back in the timeline.\n" + "And thus you are less likely to hit the limit of requests you can do in the 15 min time window.\n" + "\nYou can write newlines in your tweet with html newline ' ' (you can autocomplete it)\n" + "\nThe 'number' next to the nicks in the chat window is the of the tweet it's used\n" + "in the some of the twitter plugin commands.\n\n" + "Command desc:\n"+ "\n".join(desc_list), + " || ".join(compl_list), + "my_command_cb", "") + +# callback called when buffer is closed +# TODO rewrite this so it unloads the plugin +def buffer_close_cb(data, buffer): + # ... + #TODO handle multiple buffers and free up global buffer pointers + weechat.unhook_all() + return weechat.WEECHAT_RC_OK + +def tweet_length(message): + """Replace URLs with placeholders, 20 for http URLs, 21 for https.""" + # regexes to match URLs + octet = r'(?:2(?:[0-4]\d|5[0-5])|1\d\d|\d{1,2})' + ip_addr = r'%s(?:\.%s){3}' % (octet, octet) + # Base domain regex off RFC 1034 and 1738 + label = r'[0-9a-z][-0-9a-z]*[0-9a-z]?' + domain = r'%s(?:\.%s)*\.[a-z][-0-9a-z]*[a-z]?' % (label, label) + url_re = re.compile(r'(\w+://(?:%s|%s)(?::\d+)?(?:/[^\])>\s]*)?)' % \ + (domain, ip_addr), re.I) + + new_message = message + + for url in url_re.findall(message): + short_url = 'x' * 20 + if url.startswith('https'): + short_url = 'x' * 21 + new_message = new_message.replace(url, short_url) + + return len(new_message) + +def my_modifier_cb(data, modifier, modifier_data, string): + if not weechat.current_buffer() in friends_nicks_group: + return string + + #check if this is a commandline argument + if string == "" or string[0] == "/": + return string + + length = tweet_length(string) + + # Subtract local command argument from length + if string[:3] == ":re": + #:re a2 + length = length - 6 + + if length > 140: + index = 140 - length + string = string[:index] + weechat.color("*red") + string[index:] + + return string + +def parse_oauth_tokens(result): + for r in result.split('&'): + k, v = r.split('=') + if k == 'oauth_token': + oauth_token = v + elif k == 'oauth_token_secret': + oauth_token_secret = v + return oauth_token, oauth_token_secret + +def oauth_proc_cb(data, command, rc, out, err): + + global script_options + buffer = twit_buf + + if rc == weechat.WEECHAT_HOOK_PROCESS_ERROR: + weechat.prnt("", "Error with command '%s'" % + command.replace(script_options["oauth_token"],"").replace(script_options["oauth_secret"],"")) + return weechat.WEECHAT_RC_OK + + if out != "": + if data == "nick": + weechat.config_set_plugin('screen_name', out.strip()) + finish_init() + elif data == "friends": + process_output = ast.literal_eval(out) + for nick in process_output: + add_to_nicklist(buffer,nick) + #Get latest tweets from timeline + buffer_input_cb("silent", buffer, ":new") + elif data == "auth1": + #First auth step to request pin code + oauth_token, oauth_token_secret = parse_oauth_tokens(out) + script_options['oauth_token'] = oauth_token + script_options['oauth_secret'] = oauth_token_secret + weechat.prnt(buffer,""" + Copy the PIN number that appears on the linked web page and type ":auth " + in weechat. For example ":auth 123456" + """) + oauth_url = ('http://api.twitter.com/oauth/authorize?oauth_token=' + + oauth_token) + weechat.prnt(buffer," Please go here to get your PIN: " + oauth_url) + elif data == "auth2": + oauth_token, oauth_token_secret = parse_oauth_tokens(out) + weechat.config_set_plugin('oauth_token', oauth_token) + weechat.config_set_plugin('oauth_secret', oauth_token_secret) + weechat.config_set_plugin('auth_complete', "on") + weechat.prnt(buffer," Done! now you can begin using this script!") + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + "settings []", 10 * 1000, "oauth_proc_cb", "nick") + return weechat.WEECHAT_RC_OK + +def oauth_dance(buffer, pin = ""): + #Auth the twitter client + if pin == "": + weechat.prnt(buffer,"Hi there! We're gonna get you all set up to use this plugin.") + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + "'' " + "'' " + + "auth", 10 * 1000, "oauth_proc_cb", "auth1") + else: + oauth_verifier = pin.strip() + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + "auth "+ oauth_verifier, 10 * 1000, "oauth_proc_cb", "auth2") + +def setup_buffer(buffer): + # set title + weechat.buffer_set(buffer, "title", "Twitter buffer, type ':help' for options.") + + # disable logging, by setting local variable "no_log" to "1" + weechat.buffer_set(buffer, "localvar_set_no_log", "1") + + #create main nicklist + friends_nicks_group[buffer] = weechat.nicklist_add_group(buffer, "", "Friends", + "weechat.color.nicklist_group", 1) + + tweet_nicks_group[buffer] = weechat.nicklist_add_group(buffer, "", "Tweet_parse", + "weechat.color.nicklist_group", 1) + autocomp_group = weechat.nicklist_add_group(buffer, "", "Autocomp", + "weechat.color.nicklist_group", 1) + #newline autocomplete + weechat.nicklist_add_nick(buffer, autocomp_group, " ", 'bar_fg', '', '', 1) + + #show nicklist + weechat.buffer_set(buffer, "nicklist", "1") + + user_nick = script_options['screen_name'] + + weechat.buffer_set(buffer, "localvar_set_nick", user_nick) + + add_to_nicklist(buffer, user_nick) + # Highlight user nick + weechat.buffer_set(buffer, "highlight_words", user_nick) + +def finish_init(): + global timer_hook + + buffer = twit_buf + + if script_options['screen_name'] == "": + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + "settings []", 10 * 1000, "oauth_proc_cb", "nick") + return + setup_buffer(buffer) + + #Add friends to nick list and print new tweets + weechat.hook_process("python3 " + SCRIPT_FILE_PATH + " " + + script_options["oauth_token"] + " " + script_options["oauth_secret"] + " " + + "f " + script_options['screen_name'] + " []", 10 * 1000, "oauth_proc_cb", "friends") + +if __name__ == "__main__" and weechat_call: + weechat.register( SCRIPT_NAME , "DarkDefender", "1.0", "GPL3", "Weechat twitter client", "", "") + + if not import_ok: + weechat.prnt("", "Can't load the python twitter lib!") + weechat.prnt("", "Install it via your package manager or go to http://mike.verdone.ca/twitter/") + else: + hook_commands_and_completions() + + # Set register script options if not available + + for option, default_value in script_options.items(): + if not weechat.config_is_set_plugin(option): + if isinstance(default_value,bool): + if default_value: + default_value = "on" + else: + default_value = "off" + weechat.config_set_plugin(option, default_value) + + read_config() + # hook for config changes + + weechat.hook_config("plugins.var.python." + SCRIPT_NAME + ".*", "config_cb", "") + + # create buffer + twit_buf = weechat.buffer_new("twitter", "buffer_input_cb", "", "buffer_close_cb", "") + + #Hook text input so we can update the bar item + weechat.hook_modifier("input_text_display", "my_modifier_cb", "") + + if script_options['auth_complete']: + finish_init() + #create home_timeline stream + create_stream("twitter") + else: + weechat.prnt(twit_buf,"""You have to register this plugin with twitter for it to work. +Type ":auth" and follow the instructions to do that""") + +elif import_ok: + if sys.argv[3] == "stream": + print(twitter_stream(sys.argv)) + else: + print(get_twitter_data(sys.argv)) +else: + print("Can't load twitter python lib") + diff -Nru weechat-scripts-20130123/python/windicate.py weechat-scripts-20131007/python/windicate.py --- weechat-scripts-20130123/python/windicate.py 2013-01-23 19:00:12.000000000 +0000 +++ weechat-scripts-20131007/python/windicate.py 2013-10-07 12:14:44.000000000 +0000 @@ -1,41 +1,59 @@ # Author: Leon Bogaert +# Author: Stacey Sheldon # This Plugin Calls the libindicate bindings via python when somebody says your # nickname, sends you a query, etc. -# To make it work, you may need to download: python-indicate and python-dbus +# To make it work, you may need to download: +# python-indicate +# python-dbus +# wmctrl # Requires Weechat 0.3.0 # Released under GNU GPL v2 # # 2010-09-22, Leon : # version 0.0.1 Intial release -# -# @TODO: find out how to jump to buffer/line -# @TODO: how to communicate the click to weechat +# 2013-04-14, Stacey Sheldon +# version 0.0.2 Added two-way sync between indications and weechat +# 2013-05-01, Stacey Sheldon +# version 0.0.3 More graceful handling of missing dependencies +# # @TODO: decide what to do if a user clicks an indicator an then start typing: # * leave indicators alone # * remove indicators in the "neighbourhood" -# * If a user cliks indicator: indactor dissapears # * On click group: remove all indicators -# * When visiting buffer: remove indicators import dbus.service -import inspect import os -import tempfile + +SCRIPT_NAME = "windicate" +SCRIPT_AUTHOR = "Leon Bogaert" +SCRIPT_VERSION = "0.0.3" +SCRIPT_LICENSE = "GPL" +SCRIPT_DESC = "fills the indicate applet" + +DBUS_CONNECTION = 'org.weechat.scripts.windicate' +DBUS_OBJ_PATH = '/org/weechat/scripts/windicate' class DBUSService(dbus.service.Object): def __init__(self, messageMenu): - bus_name = dbus.service.BusName('org.weechat.scripts.windicate', bus=dbus.SessionBus()) - dbus.service.Object.__init__(self, bus_name, '/org/weechat/scripts/windicate') + bus_name = dbus.service.BusName(DBUS_CONNECTION, bus=dbus.SessionBus()) + dbus.service.Object.__init__(self, bus_name, DBUS_OBJ_PATH) self.messageMenu = messageMenu - + @dbus.service.method('org.weechat.scripts.windicate') - def add_message(self, channel, sender, body): - return self.messageMenu.add_message(channel, sender, body) + def add_message(self, buffer, brief, sender, body): + return self.messageMenu.add_message(buffer, brief, sender, body) + + @dbus.service.method('org.weechat.scripts.windicate') + def del_messages(self, buffer): + return self.messageMenu.del_messages(buffer) class MessageMenu(object): - def __init__(self): + def __init__(self, weechat_fifo, weechat_windowid): self.messages = [] + self.weechat_fifo = weechat_fifo + self.weechat_windowid = weechat_windowid + server = pyindicate.indicate_server_ref_default() server.set_type("message.im") server.set_desktop_file(self.desktop_file()) @@ -43,13 +61,27 @@ server.show() def desktop_file(self): + DESKTOP_ENTRY = """\ +[Desktop Entry] +Encoding=UTF-8 +MultipleArgs=false +Terminal=true +Exec=weechat-curses +Icon=weechat +Type=Application +Categories=Network;IRCClient; +StartupNotify=false +Name=Weechat +GenericName=IRC Client +""" file = "/usr/share/applications/weechat.desktop" if os.path.isfile(file): return file + import tempfile f = tempfile.NamedTemporaryFile(suffix='indicator', delete=False) - f.write("[Desktop Entry]\nEncoding=UTF-8\nMultipleArgs=false\nTerminal=true\nExec=weechat-curses\nIcon=weechat\nType=Application\nCategories=Network;IRCClient;\nStartupNotify=false\nName=Weechat\nGenericName=IRC Client") + f.write(DESKTOP_ENTRY) f.close() self.tmp_file = f @@ -59,18 +91,44 @@ if self.tmp_file and os.file.exists(self.tmp_file): os.unlink(self.tmp_file) + def raise_window(self): + import subprocess + try: + retcode = subprocess.call('wmctrl -i -a %s' % self.weechat_windowid, shell=True) + if retcode < 0: + # print >>sys.stderr, "Child was terminated by signal", -retcode + pass + else: + # print >>sys.stderr, "Child returned", retcode + pass + except OSError as e: + # print >>sys.stderr, "Execution failed:", e + pass + def server_click(self, server, time): - print "Server clicked!" + # tell weechat to select the first active buffer + with open (self.weechat_fifo, 'a') as f: + f.write ("irc.server.freenode */input jump_smart\n") + # raise the weechat window to the foreground + self.raise_window() - def add_message(self, channel, sender, body): + def add_message(self, buffer, brief, sender, body): for message in self.messages: - if message.channel == channel and message.sender == sender: + if message.buffer == buffer and message.sender == sender: return message.update_time() - return self.messages.append(Message(self, channel, sender, body)) + return self.messages.append(Message(self, buffer, brief, sender, body)) + + def del_messages(self, buffer): + # remove all pending indications for this buffer + for message in self.messages: + if message.buffer == buffer: + self.messages.remove(message) + message.indicator.hide() + return True class Message(object): - def __init__(self, mm, channel, sender, message): + def __init__(self, mm, buffer, brief, sender, message): # Setup the message try: # Ubuntu 9.10 and above @@ -80,7 +138,7 @@ indicator = pyindicate.IndicatorMessage() indicator.set_property("subtype", "im") - indicator.set_property("sender", "%s (%s)" % (sender, channel)) + indicator.set_property("sender", "%s (%s)" % (sender, brief)) indicator.set_property("body", message) indicator.set_property_time("time", time()) indicator.set_property('draw-attention', 'true'); @@ -90,22 +148,26 @@ self.indicator = indicator self.sender = sender self.message = message - self.channel = channel + self.brief = brief self.messageMenu = mm + self.buffer = buffer def update_time(self): self.indicator.set_property_time("time", time()) - + def message_clicked(self, indicator, time): - #How can I make weechat go there?? (/buffer self.channeli) - #Maybe if I can get dbus running in a weechat script... self.messageMenu.messages.remove(self) indicator.hide() + # tell weechat to select the buffer that triggered this indication + with open (self.messageMenu.weechat_fifo, 'a') as f: + f.write ("core.weechat */buffer %s\n" % self.buffer) + # raise the weechat window to the foreground + self.messageMenu.raise_window() class WindicateServer(object): - def __init__(self): + def __init__(self, weechat_fifo, weechat_windowid): DBusGMainLoop(set_as_default=True) - mm = MessageMenu() + mm = MessageMenu(weechat_fifo, weechat_windowid) dbs = DBUSService(mm) loop = gobject.MainLoop() @@ -115,16 +177,21 @@ p = None @classmethod - def start(cls): - file = inspect.getfile( inspect.currentframe()) + def start(cls, fifo_filename, window_windowid): + import inspect + file = inspect.getfile(inspect.currentframe()) import subprocess - args = ["/usr/bin/python", file] + args = ["/usr/bin/python", + file, + fifo_filename, + weechat_windowid] cls.p = subprocess.Popen(args) @classmethod def stop(cls): - cls.p.terminate() + if cls.p != None: + cls.p.terminate() try: import weechat @@ -137,12 +204,12 @@ import dbus from dbus.mainloop.glib import DBusGMainLoop from time import time - ws = WindicateServer() + import sys # argv + + # arguments: weechat_fifo_filename weechat_windowid + ws = WindicateServer(sys.argv[1], sys.argv[2]) # doesn't return ##### FUNCTIONS ##### -def windicate_server_ended(data, command, rc, stdout, stderr): - print "windicate_server_ended" - return weechat.WEECHAT_RC_OK def weechat_script_end(): Subprocess.stop() @@ -151,69 +218,90 @@ def notify_msg(data, bufferp, time, tags, display, is_hilight, prefix, msg): """Sends highlighted message to be printed on notification""" - if ('notify_private' in tags and + if ('notify_private' in tags and weechat.config_get_plugin('show_priv_msg') == "on") \ or (is_hilight == "1" and \ weechat.config_get_plugin('show_hilights') == "on"): - if not weechat.buffer_get_string(bufferp, "short_name"): - buffer = weechat.buffer_get_string(bufferp, "name") - else: - buffer = weechat.buffer_get_string(bufferp, "short_name") - - if ('notify_private' in tags): - buffer = "private" + # grab the fully qualified buffer name so we can jump to it later + buffer = weechat.buffer_get_string(bufferp, "name") - add_message(buffer, prefix, msg) + # choose an appropriate brief name to display in the indicator applet + if 'notify_private' in tags: + brief = "private" + else: + # prefer short_name + brief = weechat.buffer_get_string(bufferp, "short_name") + if not brief: + # fall back to full name + brief = buffer if weechat.config_get_plugin('debug') == "on": - print prefix + print "buffer: " + buffer + print "brief: " + brief + print "prefix: " + prefix + print "msg: " + msg + + # Create an object that will proxy for a particular remote object. + bus = dbus.SessionBus() + remote_object = bus.get_object(DBUS_CONNECTION, DBUS_OBJ_PATH) + remote_object.add_message(buffer, brief, prefix, msg) return weechat.WEECHAT_RC_OK -def notify_show_hi(data, signal, message): - print "data: " + data - print "signal: " + data - print "message: " + message - return weechat.WEECHAT_RC_OK +def buffer_switched(data, signal, signal_data): + buffer = weechat.buffer_get_string(signal_data, "name") + if weechat.config_get_plugin('debug') == "on": + print "data: " + data + print "signal: " + signal + print "message: " + signal_data + print "buffer: " + buffer -def notify_show_priv(data, signal, message): - print "data: " + data - print "signal: " + data - print "message: " + message - return weechat.WEECHAT_RC_OK - -def add_message(channel, sender, body): + # Create an object that will proxy for a particular remote object. bus = dbus.SessionBus() + remote_object = bus.get_object(DBUS_CONNECTION, DBUS_OBJ_PATH) + remote_object.del_messages(buffer) - # Create an object that will proxy for a particular remote object. - remote_object = bus.get_object("org.weechat.scripts.windicate", # Connection name - "/org/weechat/scripts/windicate" # Object's path - ) - remote_object.add_message(channel, sender, body) -##### END FUNCTIONS ##### + return weechat.WEECHAT_RC_OK -weechat.register("windicate", "Leon Bogaert", "0.0.1", "GPL", - "fills the indicate applet", "weechat_script_end", "") +##### END FUNCTIONS ##### -# script options settings = { - "show_hilights" : "on", - "show_priv_msg" : "on", - "time_between_msg" : "5", + 'show_hilights' : ('on', 'Should hilights trigger indications' ), + 'show_priv_msg' : ('on', 'Should privmsgs trigger indications' ), } -# Init everything -for option, default_value in settings.items(): - if weechat.config_get_plugin(option) == "": - weechat.config_set_plugin(option, default_value) - -Subprocess.start() - -#weechat.hook_process("/usr/bin/python %s" % (file,), - #-1, "windicate_server_ended", "") - -# Hook privmsg/hilights -weechat.hook_print("", "", "", 1, "notify_msg", "") -#weechat.hook_signal("weechat_highlight", "notify_show_hi", "") -#weechat.hook_signal("weechat_pv", "notify_show_priv", "") +if weechat.register(SCRIPT_NAME, + SCRIPT_AUTHOR, + SCRIPT_VERSION, + SCRIPT_LICENSE, + SCRIPT_DESC, + "weechat_script_end", + ""): + version = weechat.info_get('version_number', '') or 0 + + # Init everything + for option, default_desc in settings.items(): + if not weechat.config_is_set_plugin(option): + weechat.config_set_plugin(option, default_desc[0]) + if int(version) >= 0x00030500: + weechat.config_set_desc_plugin(option, default_desc[1]) + + # Perform some sanity checks to make sure we have everything we need to run + sanity = True + weechat_windowid = os.environ.get('WINDOWID') + if weechat_windowid == None: + weechat.prnt("", "%sEnvironment variable WINDOWID not set. This script requires an X environment to run." % weechat.prefix("error")) + sanity = False + + fifo_filename = weechat.info_get("fifo_filename", "") + if fifo_filename == "": + weechat.prnt("", "%sWeechat variable fifo_filename is not set. Is the fifo plugin enabled?" % weechat.prefix("error")) + sanity = False + + if sanity: + Subprocess.start(fifo_filename, weechat_windowid) + + # Hook privmsg/hilights + weechat.hook_print("", "", "", 1, "notify_msg", "") + weechat.hook_signal("buffer_switch", "buffer_switched", "") diff -Nru weechat-scripts-20130123/python/wtwitter.py weechat-scripts-20131007/python/wtwitter.py --- weechat-scripts-20130123/python/wtwitter.py 1970-01-01 00:00:00.000000000 +0000 +++ weechat-scripts-20131007/python/wtwitter.py 2013-10-07 12:14:49.000000000 +0000 @@ -0,0 +1,85 @@ +""" + wtwitter.py + + author: Jimmy Zelinskie + desc: Sends your latest tweet to the current buffer + usage: + /set plugins.var.python.wtwitter.twitter_handle yourusername + /wtwitter + license: GPL3 + + history: + + 0.2 - rename script to wtwitter.py (twitter is a python module) + Sebastien Helleu + + 0.1 - initial script + Jimmy Zelinskie + + 0.0 - forked from lastfm.py by + Adam Saponara