diff options
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/circe-20180525.1231/circe.el')
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/circe-20180525.1231/circe.el | 3602 |
1 files changed, 0 insertions, 3602 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/circe-20180525.1231/circe.el b/configs/shared/emacs/.emacs.d/elpa/circe-20180525.1231/circe.el deleted file mode 100644 index 721044dd2aff..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/circe-20180525.1231/circe.el +++ /dev/null @@ -1,3602 +0,0 @@ -;;; circe.el --- Client for IRC in Emacs -*- lexical-binding: t -*- - -;; Copyright (C) 2005 - 2015 Jorgen Schaefer - -;; Version: 2.10 -;; Keywords: IRC, chat -;; Author: Jorgen Schaefer <forcer@forcix.cx> -;; URL: https://github.com/jorgenschaefer/circe - -;; This file is part of Circe. - -;; This program is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; This program is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see <http://www.gnu.org/licenses/>. - -;;; Commentary: - -;; Circe is a Client for IRC in Emacs. It integrates well with the rest -;; of the editor, using standard Emacs key bindings and indicating -;; activity in channels in the status bar so it stays out of your way -;; unless you want to use it. - -;;; Code: - -(defvar circe-version "2.10" - "Circe version string.") - -(require 'circe-compat) - -(require 'ring) -(require 'timer) -(require 'lui) -(require 'lui-format) -(require 'lcs) -(require 'irc) - -;; Used to be optional. But sorry, we're in the 21st century already. -(require 'lui-irc-colors) - -;; necessary for inheriting from diff-added and diff-removed faces -(require 'diff-mode) - -(defgroup circe nil - "Yet Another Emacs IRC Client." - :prefix "circe-" - :group 'applications) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Customization Options ;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;;;;;;;;;;;;;;; -;;;; Faces ;;;; -;;;;;;;;;;;;;;; - -(defface circe-prompt-face - '((t (:weight bold :foreground "Black" :background "LightSeaGreen"))) - "The face for the Circe prompt." - :group 'circe) - -(defface circe-server-face - '((((type tty)) (:foreground "blue" :weight bold)) - (((background dark)) (:foreground "#5095cf")) - (((background light)) (:foreground "#3840b0")) - (t (:foreground "SteelBlue"))) - "The face used to highlight server messages." - :group 'circe) - -(defface circe-highlight-nick-face - '((default (:weight bold)) - (((type tty)) (:foreground "cyan")) - (((background dark)) (:foreground "#82e2ed")) - (((background light)) (:foreground "#0445b7")) - (t (:foreground "CadetBlue3"))) - "The face used to highlight messages directed to us." - :group 'circe) - -(defface circe-my-message-face '((t)) - "The face used to highlight our own messages." - :group 'circe) - -(defface circe-originator-face '((t)) - "The face used to highlight the originator of a message." - :group 'circe) - -(defface circe-topic-diff-new-face '((t (:inherit diff-added))) - "The face used for text added to a topic. -See the {topic-diff} parameter to `circe-format-server-topic'." - :group 'circe) - -(defface circe-topic-diff-removed-face '((t (:inherit diff-removed))) - "The face used for text removed from a topic. -See the {topic-diff} parameter to `circe-format-server-topic'." - :group 'circe) - -(defface circe-fool-face - '((((type tty)) (:foreground "grey40" :bold t)) - (t (:foreground "grey40"))) - "The face used for fools. -See `circe-fool-list'." - :group 'circe) - -;;;;;;;;;;;;;;;;;;; -;;;; Variables ;;;; -;;;;;;;;;;;;;;;;;;; - -(defcustom circe-default-nick (user-login-name) - "The default nick for circe." - :type 'string - :group 'circe) - -(defcustom circe-default-user circe-default-nick - "The default user name for circe." - :type 'string - :group 'circe) - -(defcustom circe-default-realname (if (string= (user-full-name) "") - circe-default-nick - (user-full-name)) - "The default real name for circe." - :type 'string - :group 'circe) - -(defcustom circe-default-ip-family nil - "Default IP family to use. - - 'nil - Use either IPv4 or IPv6. - - 'ipv4 - Use IPv4 - - 'ipv6 - Use IPv6" - :type '(choice (const :tag "Both" nil) - (const :tag "IPv4" ipv4) - (const :tag "IPv6" ipv6)) - :group 'circe) - -(defcustom circe-default-directory "~/" - "The value of `default-directory' for Circe buffers." - :type 'string - :group 'circe) - -(defcustom circe-network-options nil - "Network options. - -This alist maps network names to respective options. - -Common options: - - :pass - The IRC server password to use for this network, or a - function to fetch it. - :nick - The nick name to use (defaults to `circe-default-nick') - :user - The user name to use (defaults to `circe-default-user') - :realname - The real name to use (defaults to `circe-default-realname') - - :channels - A plist of channels to join (see `circe-channels'). - :server-buffer-name - Format to be used for the server buffer name - (see `circe-server-buffer-name') - - :host - The host name of the server to connect to. - :port - The port or service name for the server. - :use-tls - A boolean indicating as to whether to use TLS or - not (defaults to nil). If you set this, you'll likely - have to set :port as well. - :ip-family - Option to enforce a specific IP version - (defaults to `circe-default-ip-family') - - :nickserv-nick - The nick to authenticate with to nickserv, if configured. - (defaults to the value of :nick) - :nickserv-password - The password to use for nickserv - authentication or a function to fetch it. - - :sasl-username - The username for SASL authentication. - :sasl-password - The password for SASL authentication." - :type '(alist :key-type string :value-type plist) - :group 'circe) - -(defvar circe-network-defaults - '(("Freenode" :host "irc.freenode.net" :port (6667 . 6697) - :tls t - :nickserv-mask "^NickServ!NickServ@services\\.$" - :nickserv-identify-challenge "\C-b/msg\\s-NickServ\\s-identify\\s-<password>\C-b" - :nickserv-identify-command "PRIVMSG NickServ :IDENTIFY {nick} {password}" - :nickserv-identify-confirmation "^You are now identified for .*\\.$" - :nickserv-ghost-command "PRIVMSG NickServ :GHOST {nick} {password}" - :nickserv-ghost-confirmation "has been ghosted\\.$\\|is not online\\.$" - ) - ("Coldfront" :host "irc.coldfront.net" :port 6667 - :nickserv-mask "^NickServ!services@coldfront\\.net$" - :nickserv-identify-challenge "/msg\\s-NickServ\\s-IDENTIFY\\s-\C-_password\C-_" - :nickserv-identify-command "PRIVMSG NickServ :IDENTIFY {password}" - ) - ("Bitlbee" :host "localhost" :port 6667 - :nickserv-mask "\\(bitlbee\\|root\\)!\\(bitlbee\\|root\\)@" - :nickserv-identify-challenge "use the \x02identify\x02 command to identify yourself" - :nickserv-identify-command "PRIVMSG &bitlbee :identify {password}" - :nickserv-identify-confirmation "Password accepted, settings and accounts loaded" - :lagmon-disabled t - ) - ("OFTC" :host "irc.oftc.net" :port (6667 . 6697) - :nickserv-mask "^NickServ!services@services\\.oftc\\.net$" - :nickserv-identify-challenge "This nickname is registered and protected." - :nickserv-identify-command "PRIVMSG NickServ :IDENTIFY {password} {nick}" - :nickserv-identify-confirmation "^You are successfully identified as .*\\.$" - ) - ) - "Alist of networks and connection settings. - -See the `circe' command for details of this variable.") - -(defcustom circe-default-quit-message "Using Circe, the loveliest of all IRC clients" - "The default quit message when no other is given. - -This is sent when the server buffer is killed or when /QUIT is -given with no argument." - :type 'string - :group 'circe) - -(defcustom circe-default-part-message "Using Circe, the loveliest of all IRC clients" - "How to part when a channel buffer is killed, or when no -argument is given to /PART." - :type 'string - :group 'circe) - -(defcustom circe-auto-query-max 23 - "The maximum number of queries which are opened automatically. -If more messages arrive - typically in a flood situation - they -are displayed in the server buffer." - :type 'integer - :group 'circe) - -(defcustom circe-use-cycle-completion nil - "Whether Circe should use cycle completion. - -If this is not nil, Circe will set `completion-cycle-threshold' -to t locally in Circe buffers, enabling cycle completion for -nicks no matter what completion style you use in the rest of -Emacs. If you set this to nil, Circe will not touch your default -completion style." - :type 'boolean - :group 'circe) - -(defcustom circe-reduce-lurker-spam nil - "If enabled, Circe will stop showing some messages. - -This means that JOIN, PART, QUIT and NICK messages are not shown -for users on channels that have not spoken yet (\"lurker\"), or -haven't spoken in `circe-active-users-timeout' seconds. When they -speak for the first time, Circe displays their join time." - :type 'boolean - :group 'circe) - -(defcustom circe-active-users-timeout nil - "When non-nil, should be the number of seconds after which -active users are regarded as inactive again after speaking." - :type 'integer - :group 'circe) - -(defcustom circe-prompt-string (concat (propertize ">" - 'face 'circe-prompt-face) - " ") - "The string to initialize the prompt with. -To change the prompt dynamically or just in specific buffers, use -`lui-set-prompt' in the appropriate hooks." - :type 'string - :group 'circe) - -(defcustom circe-extra-nicks nil - "List of other nicks than your current one to highlight." - :type '(repeat string) - :group 'circe) - -(defcustom circe-highlight-nick-type 'sender - "How to highlight occurrences of our own nick. - - 'sender - Highlight the nick of the sender - (messages without a sender and your - own are highlighted with the occurrence - type instead) - 'occurrence - Highlight the occurrences of the nick - 'message - Highlight the message without the sender - 'all - Highlight the whole line" - :type '(choice (const :tag "Sender" sender) - (const :tag "Occurrences" occurrence) - (const :tag "Message" message) - (const :tag "Whole line" all)) - :group 'circe) - -(defcustom circe-inhibit-nick-highlight-function nil - "Function for inhibiting nick highlighting. -If non-nil, its value is called with the respective buffer -selected and point in the line that's about to get highlighted. -A non-nil return value inhibits any highlighting." - :type '(choice (const :tag "None" nil) - function) - :group 'circe) - -(defcustom circe-completion-suffix ": " - "A suffix for completed nicks at the beginning of a line." - :type '(choice (const :tag "The standard suffix" ": ")) - :group 'circe) - -(defcustom circe-ignore-list nil - "List of regular expressions to ignore. - -Each regular expression is matched against nick!user@host." - :type '(repeat regexp) - :group 'circe) - -(defcustom circe-fool-list nil - "List of regular expressions for fools. - -Each regular expression is matched against nick!user@host. - -Messages from such people are still inserted, but not shown. They -can be displayed using \\[lui-fool-toggle-display]." - :type '(repeat regexp) - :group 'circe) - -(defcustom circe-ignore-functions nil - "A list of functions to check whether we should ignore a message. - -These functions get three arguments: NICK, USERHOST, and BODY. If -one of them returns a non-nil value, the message is ignored." - :type 'hook - :group 'circe) - -(defcustom circe-split-line-length 440 - "The maximum length of a single message. -If a message exceeds this size, it is broken into multiple ones. - -IRC allows for lines up to 512 bytes. Two of them are CR LF. -And a typical message looks like this: - - :nicky!uhuser@host212223.dialin.fnordisp.net PRIVMSG #lazybastards :Hello! - -You can limit here the maximum length of the \"Hello!\" part. -Good luck." - :type 'integer - :group 'circe) - -(defcustom circe-server-max-reconnect-attempts 5 - "How often Circe should attempt to reconnect to the server. -If this is 0, Circe will not reconnect at all. If this is nil, -it will try to reconnect forever (not recommended)." - :type '(choice integer - (const :tag "Forever" nil)) - :group 'circe) - -(defcustom circe-netsplit-delay 60 - "The number of seconds a netsplit may be dormant. -If anything happens with a netsplit after this amount of time, -the user is re-notified." - :type 'number - :group 'circe) - -(defcustom circe-server-killed-confirmation 'ask-and-kill-all - "How to ask for confirmation when a server buffer is killed. -This can be one of the following values: - ask - Ask the user for confirmation - ask-and-kill-all - Ask the user, and kill all associated buffers - kill-all - Don't ask the user, and kill all associated buffers - nil - Kill first, ask never" - :type '(choice (const :tag "Ask before killing" ask) - (const :tag "Ask, then kill all associated buffers" - ask-and-kill-all) - (const :tag "Don't ask, then kill all associated buffers" - kill-all) - (const :tag "Don't ask" nil)) - :group 'circe) - -(defcustom circe-channel-killed-confirmation 'ask - "How to ask for confirmation when a channel buffer is killed. -This can be one of the following values: - ask - Ask the user for confirmation - nil - Don't ask, just kill" - :type '(choice (const :tag "Ask before killing" ask) - (const :tag "Don't ask" nil)) - :group 'circe) - -(defcustom circe-track-faces-priorities '(circe-highlight-nick-face - lui-highlight-face - circe-my-message-face - circe-server-face) - "A list of faces which should show up in the tracking. -The first face is kept if the new message has only lower faces, -or faces that don't show up at all." - :type '(repeat face) - :group 'circe) - -(defcustom circe-server-send-unknown-command-p nil - "Non-nil when Circe should just pass on commands it doesn't know. -E.g. /fnord foo bar would then just send \"fnord foo bar\" to the -server." - :type 'boolean - :group 'circe) - -(defcustom circe-server-connected-hook nil - "Hook run when we successfully connected to a server. -This is run from a 001 (RPL_WELCOME) message handler." - :type 'hook - :group 'circe) - -(defcustom circe-server-auto-join-default-type :immediate - "The default auto-join type to use. - -Possible options: - -:immediate - Immediately after registering on the server -:after-auth - After nickserv authentication succeeded -:after-cloak - After we have acquired a cloaked host name -:after-nick - After we regained our preferred nick, or after - nickserv authentication if we don't need to regain - it. See `circe-nickserv-ghost-style'. - -See `circe-channels' for more details." - :type '(choice (const :tag "Immediately" :immediate) - (const :tag "After Authentication" :after-auth) - (const :tag "After Cloaking" :after-cloak) - (const :tag "After Nick Regain" :after-nick)) - :group 'circe) - -;;;;;;;;;;;;;;;;; -;;;; Formats ;;;; -;;;;;;;;;;;;;;;;; - -(defgroup circe-format nil - "Format strings for Circe. -All these formats always allow the {mynick} and {chattarget} format -strings." - :prefix "circe-format-" - :group 'circe) - -(defcustom circe-format-not-tracked - '(circe-format-server-message - circe-format-server-notice - circe--irc-format-server-numeric - circe-format-server-topic - circe-format-server-rejoin - circe-format-server-lurker-activity - circe-format-server-topic-time - circe-format-server-topic-time-for-channel - circe-format-server-netmerge - circe-format-server-join - circe-format-server-join-in-channel - circe-format-server-mode-change - circe-format-server-nick-change-self - circe-format-server-nick-change - circe-format-server-nick-regain - circe-format-server-part - circe-format-server-netsplit - circe-format-server-quit-channel - circe-format-server-quit) - "A list of formats that should not trigger tracking." - :type '(repeat symbol) - :group 'circe-format) - -(defcustom circe-format-server-message "*** {body}" - "The format for generic server messages. -{body} - The body of the message." - :type 'string - :group 'circe-format) - -(defcustom circe-format-self-say "> {body}" - "The format for messages to queries or channels. -{nick} - Your nick. -{body} - The body of the message." - :type 'string - :group 'circe-format) - -(defcustom circe-format-self-action "* {nick} {body}" - "The format for actions to queries or channels. -{nick} - Your nick. -{body} - The body of the action." - :type 'string - :group 'circe-format) - -(defcustom circe-format-self-message "-> *{chattarget}* {body}" - "The format for messages sent to other people outside of queries. -{chattarget} - The target nick. -{body} - The body of the message." - :type 'string - :group 'circe-format) - -(defcustom circe-format-action "* {nick} {body}" - "The format for actions in queries or channels. -{nick} - The nick doing the action. -{body} - The body of the action." - :type 'string - :group 'circe-format) - -(defcustom circe-format-message-action "* *{nick}* {body}" - "The format for actions in messages outside of queries. -{nick} - The nick doing the action. -{body} - The body of the action." - :type 'string - :group 'circe-format) - -(defcustom circe-format-say "<{nick}> {body}" - "The format for normal channel or query talk. -{nick} - The nick talking. -{body} - The message." - :type 'string - :group 'circe-format) - -(defcustom circe-format-message "*{nick}* {body}" - "The format for a message outside of a query. -{nick} - The originator. -{body} - The message." - :type 'string - :group 'circe-format) - -(defcustom circe-format-notice "-{nick}- {body}" - "The format for a notice. -{nick} - The originator. -{body} - The notice." - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-notice "-Server Notice- {body}" - "The format for a server notice. -{body} - The notice." - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-topic "*** Topic change by {nick} ({userhost}): {new-topic}" - "The format for topic changes. - -The following format arguments are available: - - nick - The nick of the user who changed the topic - userhost - The user@host string of that user - channel - Where the topic change happened - new-topic - The new topic - old-topic - The previous topic - topic-diff - A colorized diff of the topics" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-lurker-activity - "*** First activity: {nick} joined {joindelta} ago." - "The format for the first-activity notice of a user. -{nick} - The originator. -{jointime} - The join time of the user (in seconds). -{joindelta} - The duration from joining until now." - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-rejoin - "*** Re-join: {nick} ({userinfo}), left {departuredelta} ago" - "The format for the re-join notice of a user. - -The following format arguments are available: - - nick - The nick of the user who joined - userhost - The user@host string of the user who joined - accountname - The account name, if the server supports this - realname - The real name, if the server supports this - userinfo - A combination of userhost, accountname, and realname - channel - A date string describing this time - departuretime - Time in seconds when the originator had left. - departuredelta - Description of the time delta since the originator left." - :type 'string - :group 'circe-format) - -(defcustom circe-server-buffer-name "{host}:{port}" - "The format for the server buffer name. - -The following format arguments are available: - - network - The name of the network - host - The host name of the server - port - The port number or service name - service - Alias for port" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-whois-idle-with-signon "*** {whois-nick} is {idle-duration} idle (signon on {signon-date}, {signon-ago} ago)" - "Format for RPL_WHOISIDLE messages. - -The following format arguments are available: - - whois-nick - The nick this is about - idle-seconds - The number of seconds this nick has been idle - idle-duration - A textual description of the duration of the idle time - signon-time - The time (in seconds since the epoch) when this user - signed on - signon-date - A date string describing this time - signon-ago - A textual description of the duraction since signon" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-whois-idle "*** {whois-nick} is {idle-duration} idle" - "Format for RPL_WHOISIDLE messages. - -The following format arguments are available: - - whois-nick - The nick this is about - idle-seconds - The number of seconds this nick has been idle - idle-duration - A textual description of the duration of the idle time" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-topic-time "*** Topic set by {setter} on {topic-date}, {topic-ago} ago" - "Format for RPL_TOPICWHOTIME messages for the current channel. - -The following format arguments are available: - - channel - The channel the topic is for - setter - The nick of the person who set the topic - setter-userhost - The user@host string of the person who set the topic - topic-time - The time the topic was set, in seconds since the epoch - topic-date - A date string describing this time - topic-ago - A textual description of the duration since the topic - was set" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-topic-time-for-channel "*** Topic for {channel} set by {setter} on {topic-date}, {topic-ago} ago" - "Format for RPL_TOPICWHOTIME messages for a channel we are not on. - -The following format arguments are available: - - channel - The channel the topic is for - setter - The nick of the person who set the topic - setter-userhost - The user@host string of the person who set the topic - topic-time - The time the topic was set, in seconds since the epoch - topic-date - A date string describing this time - topic-ago - A textual description of the duration since the topic - was set" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-channel-creation-time "*** Channel {channel} created on {date}, {ago} ago" - "Format for RPL_CREATIONTIME messages for the current channel. - -The following format arguments are available: - - channel - The channel the topic is for - date - A date string describing this time - ago - A textual description of the duration since the channel - was created" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-ctcp-ping "*** CTCP PING request from {nick} ({userhost}) to {target}: {body} ({ago} ago)" - "Format for CTCP PING requests. - -The following format arguments are available: - - nick - The nick of the user who sent this PING request - userhost - The user@host string of the user who sent this request - target - The target of the message, usually us, but can be a channel - body - The argument of the PING request, usually a number - ago - A textual description of the duration since the request - was sent, if parseable" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-ctcp-ping-reply "*** CTCP PING reply from {nick} ({userhost}) to {target}: {ago} ago ({body})" - "Format for CTCP PING replies. - -The following format arguments are available: - - nick - The nick of the user who sent this PING request - userhost - The user@host string of the user who sent this request - target - The target of the message, usually us, but can be a channel - body - The argument of the PING request, usually a number - ago - A textual description of the duration since the request - was sent, if parseable" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-ctcp "*** CTCP {command} request from {nick} ({userhost}) to {target}: {body}" - "Format for CTCP requests. - -The following format arguments are available: - - nick - The nick of the user who sent this PING request - userhost - The user@host string of the user who sent this request - target - The target of the message, usually us, but can be a channel - command - The CTCP command used - body - The argument of the PING request, usually a number" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-netsplit "*** Netsplit: {split} (Use /WL to see who left)" - "Format for netsplit notifications. - -The following format arguments are available: - - split - The name of the split, usually describing the servers involved" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-netmerge "*** Netmerge: {split}, split {ago} ago (Use /WL to see who's still missing)" - "Format for netmerge notifications. - -The following format arguments are available: - - split - The name of the split, usually describing the servers involved - time - The time when this split happened, in seconds - date - A date string describing this time - ago - A textual description of the duration since the split happened" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-join "*** Join: {nick} ({userinfo})" - "Format for join messages in a channel buffer. - -The following format arguments are available: - - nick - The nick of the user joining - userhost - The user@host string for the user - accountname - The account name, if the server supports this - realname - The real name, if the server supports this - userinfo - A combination of userhost, accountname, and realname - channel - The channel this user is joining" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-join-in-channel "*** Join: {nick} ({userinfo}) joined {channel}" - "Format for join messages in query buffers of the joining user. - -The following format arguments are available: - - nick - The nick of the user joining - userhost - The user@host string for the user - accountname - The account name, if the server supports this - realname - The real name, if the server supports this - userinfo - A combination of userhost, accountname, and realname - channel - The channel this user is joining" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-mode-change "*** Mode change: {change} on {target} by {setter} ({userhost})" - "Format for mode changes. - -The following format arguments are available: - - setter - The name of the split, usually describing the servers involved - userhost - The user@host string for the user - target - The target of this mode change - change - The actual changed modes" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-nick-change-self "*** Nick change: You are now known as {new-nick}" - "Format for nick changes of the current user. - -The following format arguments are available: - - old-nick - The old nick this change was from - new-nick - The new nick this change was to - userhost - The user@host string for the user" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-nick-change "*** Nick change: {old-nick} ({userhost}) is now known as {new-nick}" - "Format for nick changes of the current user. - -The following format arguments are available: - - old-nick - The old nick this change was from - new-nick - The new nick this change was to - userhost - The user@host string for the user" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-nick-regain "*** Nick regain: {old-nick} ({userhost}) is now known as {new-nick}" - "Format for nick changes of the current user. - -The following format arguments are available: - - old-nick - The old nick this change was from - new-nick - The new nick this change was to - userhost - The user@host string for the user" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-part "*** Part: {nick} ({userhost}) left {channel}: {reason}" - "Format for users parting a channel. - -The following format arguments are available: - - nick - The nick of the user who left - userhost - The user@host string for this user - channel - The channel they left - reason - The reason they gave for leaving" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-quit-channel "*** Quit: {nick} ({userhost}) left {channel}: {reason}" - "Format for users quitting from a channel. - -The following format arguments are available: - - nick - The nick of the user who left - userhost - The user@host string for this user - channel - The channel they left - reason - The reason they gave for leaving" - :type 'string - :group 'circe-format) - -(defcustom circe-format-server-quit "*** Quit: {nick} ({userhost}) left IRC: {reason}" - "Format for users quitting. - -The following format arguments are available: - - nick - The nick of the user who left - userhost - The user@host string for this user - reason - The reason they gave for leaving" - :type 'string - :group 'circe-format) - -;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Private variables ;;; -;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar circe-source-url "https://github.com/jorgenschaefer/circe" - "URL to Circe's source repository") - -(defvar circe-host nil - "The name of the server we're currently connected to.") -(make-variable-buffer-local 'circe-host) - -(defvar circe-port nil - "The port number or service name of the server.") -(make-variable-buffer-local 'circe-host) - -(defvar circe-network nil - "The network name of the server we're currently connected to.") -(make-variable-buffer-local 'circe-network) - -(defvar circe-ip-family nil - "The IP family in use. -See `make-network-process' and :family for valid values.") -(make-variable-buffer-local 'circe-ip-family) - -(defvar circe-nick nil - "Our current nick.") -(make-variable-buffer-local 'circe-nick) - -(defvar circe-user nil - "The current user name.") -(make-variable-buffer-local 'circe-user) - -(defvar circe-realname nil - "The current real name.") -(make-variable-buffer-local 'circe-realname) - -(defvar circe-pass nil - "The password for the current server or a function to recall it. - -If a function is set it will be called with the value of `circe-host'.") -(make-variable-buffer-local 'circe-pass) - -(defvar circe-sasl-username nil - "The username for SASL authentication.") -(make-variable-buffer-local 'circe-sasl-username) - -(defvar circe-sasl-password nil - "The password for SASL authentication. - -If a function is set it will be called with the value of -`circe-host'.") -(make-variable-buffer-local 'circe-sasl-password) - -(defvar circe-use-tls nil - "If non-nil, use `open-tls-stream' to connect to the server.") -(make-variable-buffer-local 'circe-use-tls) - -(defvar circe-server-process nil - "The process of the server connection.") -(make-variable-buffer-local 'circe-server-process) - -(defvar circe-server-last-active-buffer nil - "The last active circe buffer.") -(make-variable-buffer-local 'circe-server-last-active-buffer) - -(defvar circe-display-table nil - "A hash table mapping commands to their display functions.") - -(defvar circe-server-inhibit-auto-reconnect-p nil - "Non-nil when Circe should not reconnect. - -This can be set from commands to avoid reconnecting when the -server disconnects.") -(make-variable-buffer-local 'circe-server-inhibit-auto-reconnect-p) - -(defvar circe-chat-calling-server-buffer-and-target nil - "Internal variable to pass the server buffer and target to chat modes.") - -(defvar circe-chat-target nil - "The current target for the buffer. -This is either a channel or a nick name.") -(make-variable-buffer-local 'circe-chat-target) - -(defvar circe-nick-syntax-table - (let ((table (make-syntax-table text-mode-syntax-table)) - (special (string-to-list "[]\`_^{}|-"))) - (dolist (char special) - (modify-syntax-entry char "w" table)) - table) - "Syntax table to treat nicks as words. -This is not entirely accurate, as exact chars constituting a nick -can vary between networks.") - -(defvar circe-nickserv-mask nil - "The regular expression to identify the nickserv on this network. - -Matched against nick!user@host.") -(make-variable-buffer-local 'circe-nickserv-mask) - -(defvar circe-nickserv-identify-challenge nil - "A regular expression matching the nickserv challenge to identify.") -(make-variable-buffer-local 'circe-nickserv-identify-challenge) - -(defvar circe-nickserv-identify-command nil - "The IRC command to send to identify with nickserv. - -This must be a full IRC command. It accepts the following -formatting options: - - {nick} - The nick to identify as - {password} - The configured nickserv password") -(make-variable-buffer-local 'circe-nickserv-identify-command) - -(defvar circe-nickserv-identify-confirmation nil - "A regular expression matching a confirmation of authentication.") -(make-variable-buffer-local 'circe-nickserv-identify-confirmation) - -(defvar circe-nickserv-ghost-command nil - "The IRC command to send to regain/ghost your nick. - -This must be a full IRC command. It accepts the following -formatting options: - - {nick} - The nick to ghost - {password} - The configured nickserv password") -(make-variable-buffer-local 'circe-nickserv-ghost-command) - -(defvar circe-nickserv-ghost-confirmation nil - "A regular expression matching a confirmation for the GHOST command. - -This is used to know when we can set our nick to the regained one -Leave nil if regaining automatically sets your nick") -(make-variable-buffer-local 'circe-nickserv-ghost-confirmation) - -(defvar circe-nickserv-nick nil - "The nick we are registered with for nickserv. - -Do not set this variable directly. Use `circe-network-options' or -pass an argument to the `circe' function for this.") -(make-variable-buffer-local 'circe-nickserv-nick) - -(defvar circe-nickserv-password nil - "The password we use for nickserv on this network. - -Can be either a string or a unary function of the nick returning -a string. - -Do not set this variable directly. Use `circe-network-options' or -pass an argument to the `circe' function for this.") -(make-variable-buffer-local 'circe-nickserv-password) - -(defvar circe-channels nil - "The default channels to join on this server. - -Don't set this variable by hand, use `circe-network-options'. - -The value should be a list of channels to join, with optional -keywords to configure the behavior of the following channels. - -Best explained in an example: - -\(\"#emacs\" :after-auth \"#channel\" \"#channel2\") - -Possible keyword options are: - -:immediate - Immediately after registering on the server -:after-auth - After nickserv authentication succeeded -:after-cloak - After we have acquired a cloaked host name -:after-nick - After we regained our preferred nick, or after - nickserv authentication if we don't need to regain - it. See `circe-nickserv-ghost-style'. - -The default is set in `circe-server-auto-join-default-type'. - -A keyword in the first position of the channels list overrides -`circe-server-auto-join-default-type' for re-joining manually -joined channels.") -(make-variable-buffer-local 'circe-channels) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;; Server Buffer Management ;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; Every Circe buffer has an associated server buffer (which might be -;; the buffer itself). Circe buffers should set the -;; `circe-server-buffer' variable to the associated server buffer. - -(defun circe-server-buffer () - "Return the server buffer for the current buffer." - (let ((buf (if (eq major-mode 'circe-server-mode) - (current-buffer) - circe-server-buffer))) - (cond - ((not buf) - (error "Not in a Circe buffer")) - ((not (buffer-live-p buf)) - (error "The server buffer died, functionality is limited")) - (t - buf)))) - -(defmacro with-circe-server-buffer (&rest body) - "Run BODY with the current buffer being the current server buffer." - (declare (indent 0)) - `(with-current-buffer (circe-server-buffer) - ,@body)) - -;;;;;;;;;;;;;;;;;;;;;;; -;;; Editor Commands ;;; -;;;;;;;;;;;;;;;;;;;;;;; - -;;;###autoload -(defun circe-version () - "Display Circe's version." - (interactive) - (message "Circe %s" (circe--version))) - -(defun circe--version () - "Return Circe's version" - (let ((circe-git-version (circe--git-version))) - (if circe-git-version - (format "%s-%s" circe-version circe-git-version) - (format "%s" circe-version)))) - -(defun circe--git-version () - (let ((current-file-path (or load-file-name buffer-file-name))) - (when (or (not current-file-path) - (not (equal (file-name-nondirectory current-file-path) - "circe.el"))) - (setq current-file-path (locate-library "circe.el"))) - (let ((vcs-path (locate-dominating-file current-file-path ".git"))) - (when vcs-path - (let ((default-directory vcs-path)) - ;; chop off the trailing newline - (substring (shell-command-to-string "git rev-parse --short HEAD") - 0 -1)))))) - -;;;###autoload -(defun circe (network-or-server &rest server-options) - "Connect to IRC. - -Connect to the given network specified by NETWORK-OR-SERVER. - -When this function is called, it collects options from the -SERVER-OPTIONS argument, the user variable -`circe-network-options', and the defaults found in -`circe-network-defaults', in this order. - -If NETWORK-OR-SERVER is not found in any of these variables, the -argument is assumed to be the host name for the server, and all -relevant settings must be passed via SERVER-OPTIONS. - -All SERVER-OPTIONS are treated as variables by getting the string -\"circe-\" prepended to their name. This variable is then set -locally in the server buffer. - -See `circe-network-options' for a list of common options." - (interactive (circe--read-network-and-options)) - (let* ((options (circe--server-get-network-options network-or-server - server-options)) - (buffer (circe--server-generate-buffer options))) - (with-current-buffer buffer - (circe-server-mode) - (circe--server-set-variables options) - (circe-reconnect)) - (pop-to-buffer-same-window buffer))) - -(defun circe--read-network-and-options () - "Read a host or network name with completion. - -If it's not a network, also read some extra options. - -This uses `circe-network-defaults' and `circe-network-options' for -network names." - (let ((default-network (if (null circe-network-options) - (caar circe-network-defaults) - (caar circe-network-options))) - (networks nil) - (completion-ignore-case t) - network-or-host) - (dolist (network-spec (append circe-network-options - circe-network-defaults)) - (when (not (member (car network-spec) networks)) - (push (car network-spec) networks))) - (setq networks (sort networks 'string-lessp)) - (setq network-or-host (completing-read "Network or host: " - networks - nil nil nil nil - default-network)) - (dolist (network-name networks) - (when (equal (downcase network-or-host) - (downcase network-name)) - (setq network-or-host network-name))) - (if (member network-or-host networks) - (list network-or-host) - (list network-or-host - :host network-or-host - :port (read-number "Port: " 6667))))) - -(defun circe--server-get-network-options (network server-options) - "Combine server and network options with network defaults. - -See `circe-network-options' and `circe-network-defaults'." - (let ((options (mapcar 'circe--translate-option-names - (append server-options - (cdr (assoc network circe-network-options)) - (cdr (assoc network circe-network-defaults)) - (list :network network))))) - (when (not (plist-get options :host)) - (plist-put options :host network)) - (let ((port (plist-get options :port)) - (use-tls (plist-get options :use-tls))) - (when (consp port) - (if use-tls - (plist-put options :port (cdr port)) - (plist-put options :port (car port))))) - (dolist (required-option '(:host :port)) - (when (not (plist-get options required-option)) - (error (format "Network option %s not specified" required-option)))) - options)) - -(defun circe--translate-option-names (option) - "Translate option names to make them unique. - -Some options have multiple names, mainly for historical reasons. -Unify them here." - (cond - ((eq option :service) :port) - ((eq option :tls) :use-tls) - ((eq option :family) :ip-family) - (t option))) - -(defun circe--server-generate-buffer (options) - "Return the server buffer for the connection described in OPTIONS." - (let* ((network (plist-get options :network)) - (host (plist-get options :host)) - (port (plist-get options :port)) - (buffer-name (lui-format (or (plist-get options :server-buffer-name) - circe-server-buffer-name) - :network network - :host host - :port port - :service port))) - (generate-new-buffer buffer-name))) - -(defun circe--server-set-variables (options) - "Set buffer-local variables described in OPTIONS. - -OPTIONS is a plist as passed to `circe'. All options therein are -set as buffer-local variables. Only the first occurrence of each -variable is set." - (setq circe-nick circe-default-nick - circe-user circe-default-user - circe-realname circe-default-realname - circe-ip-family circe-default-ip-family) - (let ((done nil) - (todo options)) - (while todo - (when (not (memq (car todo) done)) - (push (car todo) done) - (let ((var (intern (format "circe-%s" - (substring (symbol-name (car todo)) 1)))) - (val (cadr todo))) - (if (boundp var) - (set (make-local-variable var) val) - (warn "Unknown option %s, ignored" (car todo))))) - (setq todo (cddr todo))))) - -(defvar circe-server-reconnect-attempts 0 - "The number of reconnect attempts that Circe has done so far. -See `circe-server-max-reconnect-attempts'.") -(make-variable-buffer-local 'circe-server-reconnect-attempts) - -(defun circe-reconnect () - "Reconnect the current server." - (interactive) - (with-circe-server-buffer - (when (or (called-interactively-p 'any) - (circe--reconnect-p)) - (setq circe-server-inhibit-auto-reconnect-p t - circe-server-reconnect-attempts (+ circe-server-reconnect-attempts - 1)) - (unwind-protect - (circe-reconnect--internal) - (setq circe-server-inhibit-auto-reconnect-p nil))))) - -(defun circe--reconnect-p () - (cond - (circe-server-inhibit-auto-reconnect-p - nil) - ((not circe-server-max-reconnect-attempts) - t) - ((<= circe-server-reconnect-attempts - circe-server-max-reconnect-attempts) - t) - (t - nil))) - -(defun circe-reconnect--internal () - "The internal function called for reconnecting unconditionally. - -Do not use this directly, use `circe-reconnect'" - (when (and circe-server-process - (process-live-p circe-server-process)) - (delete-process circe-server-process)) - (circe-display-server-message "Connecting...") - (dolist (buf (circe-server-chat-buffers)) - (with-current-buffer buf - (circe-display-server-message "Connecting..."))) - (setq circe-server-process - (irc-connect - :host circe-host - :service circe-port - :tls circe-use-tls - :ip-family circe-ip-family - :handler-table (circe-irc-handler-table) - :server-buffer (current-buffer) - :nick circe-nick - :nick-alternatives (list (circe--nick-next circe-nick) - (circe--nick-next - (circe--nick-next circe-nick))) - :user circe-user - :mode 8 - :realname circe-realname - :pass (if (functionp circe-pass) - (funcall circe-pass circe-host) - circe-pass) - :cap-req (append (when (and circe-sasl-username - circe-sasl-password) - '("sasl")) - '("extended-join")) - :nickserv-nick (or circe-nickserv-nick - circe-nick) - :nickserv-password (if (functionp circe-nickserv-password) - (funcall circe-nickserv-password circe-host) - circe-nickserv-password) - :nickserv-mask circe-nickserv-mask - :nickserv-identify-challenge circe-nickserv-identify-challenge - :nickserv-identify-command circe-nickserv-identify-command - :nickserv-identify-confirmation - circe-nickserv-identify-confirmation - :nickserv-ghost-command circe-nickserv-ghost-command - :nickserv-ghost-confirmation circe-nickserv-ghost-confirmation - :sasl-username circe-sasl-username - :sasl-password (if (functionp circe-sasl-password) - (funcall circe-sasl-password - circe-host) - circe-sasl-password) - :ctcp-version (format "Circe: Client for IRC in Emacs, version %s" - circe-version) - :ctcp-source circe-source-url - :ctcp-clientinfo "CLIENTINFO PING SOURCE TIME VERSION" - :auto-join-after-registration - (append (circe--auto-join-channel-buffers) - (circe--auto-join-list :immediate)) - :auto-join-after-host-hiding - (circe--auto-join-list :after-cloak) - :auto-join-after-nick-acquisition - (circe--auto-join-list :after-nick) - :auto-join-after-nickserv-identification - (circe--auto-join-list :after-auth) - :auto-join-after-sasl-login - (circe--auto-join-list :after-auth)))) - -(defun circe-reconnect-all () - "Reconnect all Circe connections." - (interactive) - (dolist (buf (circe-server-buffers)) - (with-current-buffer buf - (if (called-interactively-p 'any) - (call-interactively 'circe-reconnect) - (circe-reconnect))))) - -(defun circe--auto-join-list (type) - "Return the list of channels to join for type TYPE." - (let ((result nil) - (current-type circe-server-auto-join-default-type)) - (dolist (channel circe-channels) - (cond - ((keywordp channel) - (setq current-type channel)) - ((eq current-type type) - (push channel result)))) - (nreverse result))) - -(defun circe--auto-join-channel-buffers () - "Return a list of channels to join based on channel buffers. - -This includes all channel buffers of the current server, but -excludes and channel that is already listed in -`circe-channels'." - (let ((channels nil)) - (dolist (buf (circe-server-chat-buffers)) - (let ((name (with-current-buffer buf - (when (derived-mode-p 'circe-channel-mode) - circe-chat-target)))) - (when (and name - (not (member name circe-channels))) - (push name channels)))) - channels)) - -;;;;;;;;;;;;;;;;; -;;; Base Mode ;;; -;;;;;;;;;;;;;;;;; - -(defvar circe-mode-hook nil - "Hook run for any Circe mode.") - -(defvar circe-mode-map - (let ((map (make-sparse-keymap))) - (define-key map (kbd "C-c C-j") 'circe-command-JOIN) - (define-key map (kbd "C-c C-r") 'circe-reconnect) - map) - "The base keymap for all Circe modes (server, channel, query)") - -(defvar circe-server-buffer nil - "The buffer of the server associated with the current chat buffer.") -(make-variable-buffer-local 'circe-server-buffer) - -(define-derived-mode circe-mode lui-mode "Circe" - "Base mode for all Circe buffers. - -A buffer should never be in this mode directly, but rather in -modes that derive from this. - -The mode inheritance hierarchy looks like this: - -lui-mode -`-circe-mode - `-circe-server-mode - `-circe-chat-mode - `-circe-channel-mode - `-circe-query-mode" - (add-hook 'lui-pre-output-hook 'lui-irc-colors - t t) - (add-hook 'lui-pre-output-hook 'circe--output-highlight-nick - t t) - (add-hook 'completion-at-point-functions 'circe--completion-at-point - nil t) - (lui-set-prompt circe-prompt-string) - (goto-char (point-max)) - (setq lui-input-function 'circe--input - default-directory (expand-file-name circe-default-directory) - circe-server-last-active-buffer (current-buffer) - flyspell-generic-check-word-p 'circe--flyspell-check-word-p) - (when circe-use-cycle-completion - (set (make-local-variable 'completion-cycle-threshold) - t)) - ;; Tab completion should be case-insensitive - (set (make-local-variable 'completion-ignore-case) - t) - (set (make-local-variable 'tracking-faces-priorities) - circe-track-faces-priorities)) - -;;;;;;;;;;;;;;;;;;;; -;;;; Displaying ;;;; -;;;;;;;;;;;;;;;;;;;; - -(defun circe-display (format &rest keywords) - "Display FORMAT formatted with KEYWORDS in the current Circe buffer. -See `lui-format' for a description of the format. - -If FORMAT contains the word server, the resulting string receives -a `circe-server-face'. If FORMAT contains the word self, the -whole string receives a `circe-my-message-face'. If FORMAT is in -`circe-format-not-tracked', a message of this type is never -tracked by Lui. - -Keywords with the name :nick receive a `circe-originator-face'. - -It is always possible to use the mynick or target formats." - (when (not (circe--display-ignored-p format keywords)) - (let* ((name (symbol-name format)) - (face (cond - ((string-match "\\<server\\>" name) - 'circe-server-face) - ((string-match "\\<self\\>" name) - 'circe-my-message-face))) - (keywords (append `(:mynick ,(circe-nick) - :chattarget ,circe-chat-target) - (circe--display-add-nick-property - (if (and (not (null keywords)) - (null (cdr keywords))) - (car keywords) - keywords)))) - (text (lui-format format keywords))) - (when (circe--display-fool-p format keywords) - (add-face-text-property 0 (length text) - 'circe-fool-face t text) - (put-text-property 0 (length text) - 'lui-fool t - text)) - (when face - (add-face-text-property 0 (length text) - face t text)) - (lui-insert text - (memq format circe-format-not-tracked))))) - -(defun circe-display-server-message (message) - "Display MESSAGE as a server message." - (circe-display 'circe-format-server-message - :body message)) - -(defun circe--display-add-nick-property (keywords) - "Add a face to the value of the :nick property in KEYWORDS." - (let ((keyword nil)) - (mapcar (lambda (entry) - (cond - ((or (eq keyword :nick) - (eq keyword 'nick)) - (setq keyword nil) - (propertize entry 'face 'circe-originator-face)) - (t - (setq keyword entry) - entry))) - keywords))) - -(defun circe--display-ignored-p (_format keywords) - (let ((nick (plist-get keywords :nick)) - (userhost (plist-get keywords :userhost)) - (body (plist-get keywords :body))) - (circe--ignored-p nick userhost body))) - -(defun circe--display-fool-p (_format keywords) - (let ((nick (plist-get keywords :nick)) - (userhost (plist-get keywords :userhost)) - (body (plist-get keywords :body))) - (circe--fool-p nick userhost body))) - -(defun circe--ignored-p (nick userhost body) - "True if this user or message is being ignored. - -See `circe-ignore-functions' and `circe-ignore-list'. - -NICK, USER and HOST should be the sender of a the command -COMMAND, which had the arguments ARGS." - (or (run-hook-with-args-until-success 'circe-ignore-functions - nick userhost body) - (circe--ignore-matches-p nick userhost body circe-ignore-list))) - -(defun circe--fool-p (nick userhost body) - "True if this user or message is a fool. - -See `circe-fool-list'. - -NICK, USER and HOST should be the sender of a the command -COMMAND, which had the arguments ARGS." - (circe--ignore-matches-p nick userhost body circe-fool-list)) - -(defun circe--ignore-matches-p (nick userhost body patterns) - "Check if a given command does match an ignore pattern. - -A pattern matches if it either matches the user NICK!USER@HOST, -or if it matches the first word in BODY. - -PATTERNS should be the list of regular expressions." - (let ((string (format "%s!%s" nick userhost)) - (target (when (and body - (string-match "^\\([^ ]*\\)[:,]" body)) - (match-string 1 body)))) - (catch 'return - (dolist (regex patterns) - (when (string-match regex string) - (throw 'return t)) - (when (and (stringp target) - (string-match regex target)) - (throw 'return t))) - nil))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;; Nick Highlighting ;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun circe--output-highlight-nick () - "Highlight the nick of the user in the buffer. - -This is used in `lui-pre-output-hook'." - (goto-char (or (text-property-any (point-min) (point-max) - 'lui-format-argument 'body) - (point-min))) - (when (or (not circe-inhibit-nick-highlight-function) - (not (funcall circe-inhibit-nick-highlight-function))) - (let* ((nick (circe-nick)) - (nicks (append (and nick (list nick)) - circe-extra-nicks))) - (when nicks - ;; Can't use \<...\> because that won't match for \<forcer-\> We - ;; might eventually use \_< ... \_> if we define symbols to be - ;; nicks \\= is necessary, because it might be found right where we - ;; are, and that might not be the beginning of a line... (We start - ;; searching from the beginning of the body) - (let ((nick-regex (concat "\\(?:^\\|\\W\\|\\=\\)" - "\\(" (regexp-opt nicks) "\\)" - "\\(?:$\\|\\W\\)"))) - (cond - ((eq circe-highlight-nick-type 'sender) - (if (text-property-any (point-min) - (point-max) - 'face 'circe-originator-face) - (when (re-search-forward nick-regex nil t) - (circe--extend-text-having-face - (point-min) (point-max) - 'circe-originator-face - 'circe-highlight-nick-face)) - (let ((circe-highlight-nick-type 'occurrence)) - (circe--output-highlight-nick)))) - ((eq circe-highlight-nick-type 'occurrence) - (while (re-search-forward nick-regex nil t) - (add-face-text-property (match-beginning 1) - (match-end 1) - 'circe-highlight-nick-face))) - ((eq circe-highlight-nick-type 'message) - (when (re-search-forward nick-regex nil t) - (let* ((start (text-property-any (point-min) - (point-max) - 'lui-format-argument 'body)) - (end (when start - (next-single-property-change start - 'lui-format-argument)))) - (when (and start end) - (add-face-text-property start end - 'circe-highlight-nick-face))))) - ((eq circe-highlight-nick-type 'all) - (when (re-search-forward nick-regex nil t) - (add-face-text-property (point-min) (point-max) - 'circe-highlight-nick-face))))))))) - -(defun circe--extend-text-having-face (from to existing new) - "Extend property values. - -In the text between FROM and TO, find any text that has its face -property set to EXISTING, and prepend NEW to the value of its -face property, when necessary by turning it into a list." - (let ((beg (text-property-any from to 'face existing))) - (while beg - (let ((end (next-single-property-change beg 'face))) - (add-face-text-property beg end new) - (setq beg (text-property-any end to 'face existing)))))) - -;;;;;;;;;;;;;;; -;;;; Input ;;;; -;;;;;;;;;;;;;;; - -(defun circe--input (str) - "Process STR as input. - -This detects commands and interprets them, or sends the input -using the /SAY command." - (set-text-properties 0 (length str) nil str) - (cond - ((string= str "") - nil) - ;; Ignore commands in multiline input - ((and (not (string-match "\n" str)) - (string-match "\\`/\\([^/ ][^ ]*\\|[^/ ]*\\) ?\\([^\n]*\\)\\'" str)) - (let* ((command (match-string 1 str)) - (args (match-string 2 str)) - (handler (intern-soft (format "circe-command-%s" - (upcase command))))) - (cond - ((string= command "") - (circe-command-SAY args)) - (handler - (funcall handler args)) - (circe-server-send-unknown-command-p - (irc-send-raw (circe-server-process) - (format "%s %s" - (upcase command) - args))) - (t - (circe-display-server-message (format "Unknown command: %s" - command)))))) - (t - (mapc #'circe-command-SAY - (circe--list-drop-right (split-string str "\n") - "^ *$"))))) - -;;;;;;;;;;;;;;;;;; -;;;; Flyspell ;;;; -;;;;;;;;;;;;;;;;;; - -(defun circe--flyspell-check-word-p () - "Return a true value if flyspell check the word before point. - -This is a suitable value for `flyspell-generic-check-word-p'. It -will also call `lui-flyspell-check-word-p'." - (cond - ((not (lui-flyspell-check-word-p)) - nil) - ((circe-channel-user-p (circe--flyspell-nick-before-point)) - nil) - (t - t))) - -(defun circe--flyspell-nick-before-point () - "Return the IRC nick before point" - (with-syntax-table circe-nick-syntax-table - (let (beg end) - (save-excursion - (forward-word -1) - (setq beg (point)) - (forward-word 1) - (setq end (point))) - (buffer-substring beg end)))) - -;;;;;;;;;;;;;;;;;;;; -;;;; Completion ;;;; -;;;;;;;;;;;;;;;;;;;; - -(defun circe--completion-at-point () - "Return a list of possible completions for the current buffer. - -This is used in `completion-at-point-functions'." - ;; Use markers so they move when input happens - (let ((start (make-marker)) - (end (make-marker))) - (set-marker end (point)) - (set-marker start - (save-excursion - (when (or (looking-back (regexp-quote - circe-completion-suffix) - (length circe-completion-suffix)) - (looking-back " " 1)) - (goto-char (match-beginning 0))) - (cond - ((<= (point) lui-input-marker) - lui-input-marker) - ((re-search-backward "\\s-" lui-input-marker t) - (1+ (point))) - (t - lui-input-marker)))) - (list start end 'circe--completion-table))) - -(defun circe--completion-table (string pred action) - "Completion table to use for Circe buffers. - -See `minibuffer-completion-table' for details." - (cond - ;; Best completion of STRING - ((eq action nil) - (try-completion string - (circe--completion-candidates - (if (= (- (point) (length string)) - lui-input-marker) - circe-completion-suffix - " ")) - pred)) - ;; A list of possible completions of STRING - ((eq action t) - (all-completions string - (circe--completion-candidates - (if (= (- (point) (length string)) - lui-input-marker) - circe-completion-suffix - " ")) - pred)) - ;; t iff STRING is a valid completion as it stands - ((eq action 'lambda) - (test-completion string - (circe--completion-candidates - (if (= (- (point) (length string)) - lui-input-marker) - circe-completion-suffix - " ")) - pred)) - ;; Boundaries - ((eq (car-safe action) 'boundaries) - `(boundaries 0 . ,(length (cdr action)))) - ;; Metadata - ((eq action 'metadata) - '(metadata (cycle-sort-function . circe--completion-sort))))) - -(defun circe--completion-clean-nick (string) - (with-temp-buffer - (insert string) - (goto-char (point-max)) - (when (or (looking-back circe-completion-suffix nil) - (looking-back " " nil)) - (replace-match "")) - (buffer-string))) - -(defun circe--completion-sort (collection) - "Sort the COLLECTION by channel activity for nicks." - (let* ((proc (circe-server-process)) - (channel (when (and circe-chat-target proc) - (irc-connection-channel proc circe-chat-target))) - (decorated (mapcar (lambda (entry) - (let* ((nick (circe--completion-clean-nick - entry)) - (user (when channel - (irc-channel-user channel nick)))) - (list (when user - (irc-user-last-activity-time user)) - (length entry) - entry))) - collection)) - (sorted (sort decorated - (lambda (a b) - (cond - ((and (car a) - (car b)) - (> (car a) - (car b))) - ((and (not (car a)) - (not (car b))) - (< (cadr a) - (cadr b))) - ((car a) - t) - (t - nil)))))) - (mapcar (lambda (entry) - (nth 2 entry)) - sorted))) - -;; FIXME: I do not know why this is here. -(defvar circe--completion-old-completion-all-sorted-completions nil - "Variable to know if we can return a cached result.") -(make-variable-buffer-local - 'circe--completion-old-completion-all-sorted-completions) -(defvar circe--completion-cache nil - "The results we can cache.") -(make-variable-buffer-local 'circe--completion-cache) - -(defun circe--completion-candidates (nick-suffix) - (if (and circe--completion-old-completion-all-sorted-completions - (eq completion-all-sorted-completions - circe--completion-old-completion-all-sorted-completions)) - circe--completion-cache - (let ((completions (append (circe--commands-list) - (mapcar (lambda (buf) - (with-current-buffer buf - circe-chat-target)) - (circe-server-channel-buffers))))) - (cond - ;; In a server buffer, complete all nicks in all channels - ((eq major-mode 'circe-server-mode) - (dolist (buf (circe-server-channel-buffers)) - (with-current-buffer buf - (dolist (nick (circe-channel-nicks)) - (setq completions (cons (concat nick nick-suffix) - completions)))))) - ;; In a channel buffer, only complete nicks in this channel - ((eq major-mode 'circe-channel-mode) - (setq completions (append (delete (concat (circe-nick) - nick-suffix) - (mapcar (lambda (nick) - (concat nick nick-suffix)) - (circe-channel-nicks))) - completions))) - ;; In a query buffer, only complete this query partner - ((eq major-mode 'circe-query-mode) - (setq completions (cons (concat circe-chat-target nick-suffix) - completions))) - ;; Else, we're doing something wrong - (t - (error "`circe-possible-completions' called outside of Circe"))) - (setq circe--completion-old-completion-all-sorted-completions - completion-all-sorted-completions - circe--completion-cache completions) - completions))) - -(defun circe--commands-list () - "Return a list of possible Circe commands." - (mapcar (lambda (symbol) - (let ((str (symbol-name symbol))) - (if (string-match "^circe-command-\\(.*\\)" str) - (concat "/" (match-string 1 str) " ") - str))) - (apropos-internal "^circe-command-"))) - -;;;;;;;;;;;;;;;;;;; -;;; Server Mode ;;; -;;;;;;;;;;;;;;;;;;; - -(defvar circe-server-mode-hook nil - "Hook run when a new Circe server buffer is created.") - -(defvar circe-server-mode-map (make-sparse-keymap) - "The key map for server mode buffers.") - -(define-derived-mode circe-server-mode circe-mode "Circe Server" - "The mode for circe server buffers. - -This buffer represents a server connection. When you kill it, the -server connection is closed. This will make all associated -buffers unusable. Be sure to use \\[circe-reconnect] if you want -to reconnect to the server. - -\\{circe-server-mode-map}" - (add-hook 'kill-buffer-hook 'circe-server-killed nil t)) - -(defun circe-server-killed () - "Run when the server buffer got killed. - -This will IRC, and ask the user whether to kill all of the -server's chat buffers." - (when circe-server-killed-confirmation - (when (not (y-or-n-p - (if (eq circe-server-killed-confirmation 'ask-and-kill-all) - "Really kill all buffers of this server? (if not, try `circe-reconnect') " - "Really kill the IRC connection? (if not, try `circe-reconnect') "))) - (error "Buffer not killed as per user request"))) - (setq circe-server-inhibit-auto-reconnect-p t) - (ignore-errors - (irc-send-QUIT circe-server-process circe-default-quit-message)) - (ignore-errors - (delete-process circe-server-process)) - (when (or (eq circe-server-killed-confirmation 'ask-and-kill-all) - (eq circe-server-killed-confirmation 'kill-all)) - (dolist (buf (circe-server-chat-buffers)) - (let ((circe-channel-killed-confirmation nil)) - (kill-buffer buf))))) - -(defun circe-server-buffers () - "Return a list of all server buffers in this Emacs instance." - (let ((result nil)) - (dolist (buf (buffer-list)) - (with-current-buffer buf - (when (eq major-mode 'circe-server-mode) - (setq result (cons buf result))))) - (nreverse result))) - -(defun circe-server-process () - "Return the current server process." - (with-circe-server-buffer - circe-server-process)) - -(defun circe-server-my-nick-p (nick) - "Return non-nil when NICK is our current nick." - (let ((proc (circe-server-process))) - (when proc - (irc-current-nick-p proc nick)))) - -(defun circe-nick () - "Return our current nick." - (let ((proc (circe-server-process))) - (when proc - (irc-current-nick proc)))) - -(defun circe-server-last-active-buffer () - "Return the last active buffer of this server." - (with-circe-server-buffer - (if (and circe-server-last-active-buffer - (bufferp circe-server-last-active-buffer) - (buffer-live-p circe-server-last-active-buffer)) - circe-server-last-active-buffer - (current-buffer)))) - -;; There really ought to be a hook for this -(defadvice select-window (after circe-server-track-select-window - (window &optional norecord)) - "Remember the current buffer as the last active buffer. -This is used by Circe to know where to put spurious messages." - (with-current-buffer (window-buffer window) - (when (derived-mode-p 'circe-mode) - (let ((buf (current-buffer))) - (ignore-errors - (with-circe-server-buffer - (setq circe-server-last-active-buffer buf))))))) -(ad-activate 'select-window) - -(defun circe-reduce-lurker-spam () - "Return the value of `circe-reduce-lurker-spam'. - -This uses a buffer-local value first, then the one in the server -buffer. - -Use this instead of accessing the variable directly to enable -setting the variable through network options." - (if (local-variable-p 'circe-reduce-lurker-spam) - circe-reduce-lurker-spam - (with-circe-server-buffer - circe-reduce-lurker-spam))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;; Chat Buffer Management ;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; Server buffers keep track of associated chat buffers. This enables -;; us to not rely on buffer names staying the same, as well as keeping -;; buffers from different servers and even server connections apart -;; cleanly. - -(defvar circe-server-chat-buffer-table nil - "A hash table of chat buffers associated with this server.") -(make-variable-buffer-local 'circe-server-chat-buffer-table) - -(defun circe-server-get-chat-buffer (target) - "Return the chat buffer addressing TARGET, or nil if none." - (with-circe-server-buffer - (when circe-server-chat-buffer-table - (let* ((target-name (irc-isupport--case-fold (circe-server-process) - target)) - (buf (gethash target-name circe-server-chat-buffer-table))) - (if (buffer-live-p buf) - buf - (remhash target-name circe-server-chat-buffer-table) - nil))))) - -(defun circe-server-create-chat-buffer (target chat-mode) - "Return a new buffer addressing TARGET in CHAT-MODE." - (with-circe-server-buffer - (let* ((target-name (irc-isupport--case-fold (circe-server-process) - target)) - (chat-buffer (generate-new-buffer target)) - (server-buffer (current-buffer)) - (circe-chat-calling-server-buffer-and-target (cons server-buffer - target-name))) - (when (not circe-server-chat-buffer-table) - (setq circe-server-chat-buffer-table (make-hash-table :test 'equal))) - (puthash target-name chat-buffer circe-server-chat-buffer-table) - (with-current-buffer chat-buffer - (funcall chat-mode)) - chat-buffer))) - -(defun circe-server-get-or-create-chat-buffer (target chat-mode) - "Return a buffer addressing TARGET; create one in CHAT-MODE if none exists." - (let ((buf (circe-server-get-chat-buffer target))) - (if buf - buf - (circe-server-create-chat-buffer target chat-mode)))) - -(defun circe-server-remove-chat-buffer (target-or-buffer) - "Remove the buffer addressing TARGET-OR-BUFFER." - (with-circe-server-buffer - (let* ((target (if (bufferp target-or-buffer) - (circe-server-chat-buffer-target target-or-buffer) - target-or-buffer)) - (target-name (irc-isupport--case-fold (circe-server-process) - target))) - (remhash target-name circe-server-chat-buffer-table)))) - -(defun circe-server-rename-chat-buffer (old-name new-name) - "Note that the chat buffer addressing OLD-NAME now addresses NEW-NAME." - (with-circe-server-buffer - (let* ((old-target-name (irc-isupport--case-fold (circe-server-process) - old-name)) - (new-target-name (irc-isupport--case-fold (circe-server-process) - new-name)) - (buf (gethash old-target-name circe-server-chat-buffer-table))) - (when buf - (remhash old-target-name circe-server-chat-buffer-table) - (puthash new-target-name buf circe-server-chat-buffer-table) - (with-current-buffer buf - (setq circe-chat-target new-name) - (rename-buffer new-name t)))))) - -(defun circe-server-chat-buffer-target (&optional buffer) - "Return the chat target of BUFFER, or the current buffer if none." - (if buffer - (with-current-buffer buffer - circe-chat-target) - circe-chat-target)) - -(defun circe-server-chat-buffers () - "Return the list of chat buffers on this server." - (with-circe-server-buffer - (when circe-server-chat-buffer-table - (let ((buffer-list nil)) - (maphash (lambda (target-name buffer) - (if (buffer-live-p buffer) - (push buffer buffer-list) - (remhash target-name circe-server-chat-buffer-table))) - circe-server-chat-buffer-table) - buffer-list)))) - -(defun circe-server-channel-buffers () - "Return a list of all channel buffers of this server." - (let ((result nil)) - (dolist (buf (circe-server-chat-buffers)) - (with-current-buffer buf - (when (eq major-mode 'circe-channel-mode) - (setq result (cons buf result))))) - (nreverse result))) - -;;;;;;;;;;;;;;;;; -;;; Chat Mode ;;; -;;;;;;;;;;;;;;;;; - -(defvar circe-chat-mode-hook nil - "Hook run when a new chat buffer (channel or query) is created.") - -(defvar circe-chat-mode-map (make-sparse-keymap) - "Base key map for all Circe chat buffers (channel, query).") - -;; Defined here as we use it, but do not necessarily want to use the -;; full module. -(defvar lui-logging-format-arguments nil - "A list of arguments to be passed to `lui-format'. -This can be used to extend the formatting possibilities of the -file name for lui applications.") -(make-variable-buffer-local 'lui-logging-format-arguments) - -(define-derived-mode circe-chat-mode circe-mode "Circe Chat" - "The circe chat major mode. - -This is the common mode used for both queries and channels. -It should not be used directly. -TARGET is the default target to send data to. -SERVER-BUFFER is the server buffer of this chat buffer." - (setq circe-server-buffer (car circe-chat-calling-server-buffer-and-target) - circe-chat-target (cdr circe-chat-calling-server-buffer-and-target)) - (let ((network (with-circe-server-buffer - circe-network))) - (make-local-variable 'mode-line-buffer-identification) - (setq mode-line-buffer-identification - (list (format "%%b@%-8s" network))) - (setq lui-logging-format-arguments - `(:target ,circe-chat-target :network ,network))) - (when (equal circe-chat-target "#emacs-circe") - (set (make-local-variable 'lui-button-issue-tracker) - "https://github.com/jorgenschaefer/circe/issues/%s"))) - -(defun circe-chat-disconnected () - "The current buffer got disconnected." - (circe-display-server-message "Disconnected")) - -;;;;;;;;;;;;;;;;;;;; -;;; Channel Mode ;;; -;;;;;;;;;;;;;;;;;;;; - -(defvar circe-channel-mode-hook nil - "Hook run in a new channel buffer.") - -(defvar circe-channel-mode-map - (let ((map (make-sparse-keymap))) - (define-key map (kbd "C-c C-n") 'circe-command-NAMES) - (define-key map (kbd "C-c C-t") 'circe-command-CHTOPIC) - map) - "The key map for channel mode buffers.") - -(define-derived-mode circe-channel-mode circe-chat-mode "Circe Channel" - "The circe channel chat major mode. -This mode represents a channel you are talking in. - -TARGET is the default target to send data to. -SERVER-BUFFER is the server buffer of this chat buffer. - -\\{circe-channel-mode-map}" - (add-hook 'kill-buffer-hook 'circe-channel-killed nil t)) - -(defun circe-channel-killed () - "Called when the channel buffer got killed. - -If we are not on the channel being killed, do nothing. Otherwise, -if the server is live, and the user wants to kill the buffer, -send PART to the server and clean up the channel's remaining -state." - (when (buffer-live-p circe-server-buffer) - (when (and circe-channel-killed-confirmation - (not (y-or-n-p "Really leave this channel? "))) - (error "Channel not left.")) - (ignore-errors - (irc-send-PART (circe-server-process) - circe-chat-target - circe-default-part-message)) - (ignore-errors - (circe-server-remove-chat-buffer circe-chat-target)))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;; Channel User Tracking ;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; Channel mode buffers provide some utility functions to check if a -;; given user is idle or not. - -(defun circe-channel-user-nick-regain-p (_old new) - "Return true if a nick change from OLD to NEW constitutes a nick regain. - -A nick was regained if the NEW nick was also a recent user." - (let ((channel (irc-connection-channel (circe-server-process) - circe-chat-target))) - (when channel - (irc-channel-recent-user channel new)))) - -(defun circe-channel-user-p (nick) - "Return non-nil when NICK belongs to a channel user." - (cond - ((eq major-mode 'circe-query-mode) - (irc-string-equal-p (circe-server-process) - nick - circe-chat-target)) - ((eq major-mode 'circe-channel-mode) - (let ((channel (irc-connection-channel (circe-server-process) - circe-chat-target))) - (when channel - (if (irc-channel-user channel nick) - t - nil)))))) - -(defun circe-channel-nicks () - "Return a list of nicks in the current channel." - (let* ((channel (irc-connection-channel (circe-server-process) - circe-chat-target)) - (nicks nil)) - (when channel - (maphash (lambda (_folded-nick user) - (push (irc-user-nick user) nicks)) - (irc-channel-users channel))) - nicks)) - -(defun circe-user-channels (nick) - "Return a list of channel buffers for the user named NICK." - (let* ((result nil)) - (dolist (channel (irc-connection-channel-list (circe-server-process))) - (when (irc-channel-user channel nick) - (let* ((name (irc-channel-name channel)) - (buf (circe-server-get-chat-buffer name))) - (when buf - (push buf result))))) - result)) - -(defun circe-lurker-p (nick) - "Return a true value if this nick is regarded inactive." - (let* ((channel (irc-connection-channel (circe-server-process) - circe-chat-target)) - (user (when channel - (irc-channel-user channel nick))) - (recent-user (when channel - (irc-channel-recent-user channel nick))) - (last-active (cond - (user - (irc-user-last-activity-time user)) - (recent-user - (irc-user-last-activity-time recent-user))))) - (cond - ;; If we do not track lurkers, no one is ever a lurker. - ((not (circe-reduce-lurker-spam)) - nil) - ;; We ourselves are never lurkers (in this sense). - ((circe-server-my-nick-p nick) - nil) - ;; Someone who isn't even on the channel (e.g. NickServ) isn't a - ;; lurker, either. - ((and (not user) - (not recent-user)) - nil) - ;; If someone has never been active, they most definitely *are* a - ;; lurker. - ((not last-active) - t) - ;; But if someone has been active, and we mark active users - ;; inactive again after a timeout ... - (circe-active-users-timeout - ;; They are still lurkers if their activity has been too long - ;; ago. - (> (- (float-time) - last-active) - circe-active-users-timeout)) - ;; Otherwise, they have been active and we don't mark active - ;; users inactive again, so nope, not a lurker. - (t - nil)))) - -(defun circe-lurker-rejoin-p (nick channel) - "Return true if NICK is rejoining CHANNEL. - -A user is considered to be rejoining if they were on the channel -shortly before, and were active then." - (let* ((channel (irc-connection-channel (circe-server-process) - channel)) - (user (when channel - (irc-channel-recent-user channel nick)))) - (when user - (irc-user-last-activity-time user)))) - -(defun circe-lurker-display-active (nick userhost) - "Show that this user is active if they are a lurker." - (let* ((channel (irc-connection-channel (circe-server-process) - circe-chat-target)) - (user (when channel - (irc-channel-user channel nick))) - (join-time (when user - (irc-user-join-time user)))) - (when (and (circe-lurker-p nick) - ;; If we saw them when we joined the channel, no need to - ;; say "they're suddenly active!!111one". - join-time) - (circe-display 'circe-format-server-lurker-activity - :nick nick - :userhost (or userhost "server") - :jointime join-time - :joindelta (circe-duration-string - (- (float-time) - join-time)))))) - -;;;;;;;;;;;;;;;;;; -;;; Query Mode ;;; -;;;;;;;;;;;;;;;;;; - -(defvar circe-query-mode-hook nil - "Hook run when query mode is activated.") - -(defvar circe-query-mode-map - (let ((map (make-sparse-keymap))) - (set-keymap-parent map circe-chat-mode-map) - map) - "The key map for query mode buffers.") - -(define-derived-mode circe-query-mode circe-chat-mode "Circe Query" - "The circe query chat major mode. -This mode represents a query you are talking in. - -TARGET is the default target to send data to. -SERVER-BUFFER is the server buffer of this chat buffer. - -\\{circe-query-mode-map}" - (add-hook 'kill-buffer-hook 'circe-query-killed nil t)) - -(defun circe-query-killed () - "Called when the query buffer got killed." - (ignore-errors - (circe-server-remove-chat-buffer circe-chat-target))) - -(defun circe-query-auto-query-buffer (who) - "Return a buffer for a query with `WHO'. - -This adheres to `circe-auto-query-max'." - (or (circe-server-get-chat-buffer who) - (when (< (circe--query-count) - circe-auto-query-max) - (circe-server-get-or-create-chat-buffer who 'circe-query-mode)))) - -(defun circe--query-count () - "Return the number of queries on the current server." - (let ((num 0)) - (dolist (buf (circe-server-chat-buffers)) - (with-current-buffer buf - (when (eq major-mode 'circe-query-mode) - (setq num (+ num 1))))) - num)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; IRC Protocol Handling ;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar circe--irc-handler-table nil - "The handler table for Circe's IRC connections. - -Do not use this directly. Instead, call `circe-irc-handler-table'.") - -(defun circe-irc-handler-table () - (when (not circe--irc-handler-table) - (let ((table (irc-handler-table))) - (irc-handler-add table "irc.registered" #'circe--irc-conn-registered) - (irc-handler-add table "conn.disconnected" #'circe--irc-conn-disconnected) - (irc-handler-add table nil #'circe--irc-display-event) - (irc-handle-registration table) - (irc-handle-ping-pong table) - (irc-handle-isupport table) - (irc-handle-initial-nick-acquisition table) - (irc-handle-ctcp table) - (irc-handle-state-tracking table) - (irc-handle-nickserv table) - (irc-handle-auto-join table) - (setq circe--irc-handler-table table))) - circe--irc-handler-table) - -(defun circe--irc-conn-registered (conn _event _nick) - (with-current-buffer (irc-connection-get conn :server-buffer) - (setq circe-server-reconnect-attempts 0) - (run-hooks 'circe-server-connected-hook))) - -(defun circe--irc-conn-disconnected (conn _event) - (with-current-buffer (irc-connection-get conn :server-buffer) - (dolist (buf (circe-server-chat-buffers)) - (with-current-buffer buf - (circe-chat-disconnected))) - - (circe-reconnect))) - -(defun circe--irc-display-event (conn event &optional sender &rest args) - "Display an IRC message. - -NICK, USER and HOST specify the originator of COMMAND with ARGS -as arguments." - (with-current-buffer (irc-connection-get conn :server-buffer) - (let* ((display (circe-get-display-handler event)) - (nick (when sender - (irc-userstring-nick sender))) - (userhost (when sender - (irc-userstring-userhost sender)))) - (cond - ;; Functions get called - ((functionp display) - (apply display nick userhost event args)) - ;; Lists describe patterns - ((consp display) - (circe--irc-display-format (elt display 1) - (elt display 0) - nick userhost event args)) - ;; No configured display handler, show a default - (t - (circe--irc-display-default nick userhost event args)))))) - -(defvar circe--irc-format-server-numeric "*** %s" - "The format to use for server messages. Do not set this.") - -(defun circe--irc-display-format (format target nick userhost event args) - (let* ((target+name (circe--irc-display-target target nick args)) - (target (car target+name)) - (name (cdr target+name)) - (origin (if userhost - (format "%s (%s)" nick userhost) - (format "%s" nick)))) - (with-current-buffer (or target - (circe-server-last-active-buffer)) - (let ((circe--irc-format-server-numeric - (if target - (format "*** %s" format) - (format "*** [%s] %s" name format)))) - (circe-display 'circe--irc-format-server-numeric - :nick (or nick "(unknown)") - :userhost (or userhost "server") - :origin origin - :event event - :command event - :target name - :indexed-args args))))) - -(defun circe--irc-display-target (target nick args) - "Return the target buffer and name. -The buffer might be nil if it is not alive. - -See `circe-set-display-handler' for a description of target. - -NICK and USERHOST are the originator of COMMAND which had ARGS as -arguments." - (cond - ((eq target 'nick) - (cons (circe-server-get-chat-buffer nick) - nick)) - ((numberp target) - (let ((name (nth target - args))) - (cons (circe-server-get-chat-buffer name) - name))) - ((eq target 'active) - (let ((buf (circe-server-last-active-buffer))) - (cons buf - (buffer-name buf)))) - ((eq target 'server) - (cons (current-buffer) (buffer-name))) - (t - (error "Bad target in format string: %s" target)))) - -(defun circe--irc-display-default (nick userhost event args) - (with-current-buffer (circe-server-last-active-buffer) - (let ((target (if (circe-server-my-nick-p (car args)) - "" - (format " to %s" (car args))))) - (cond - ((string-match "\\`irc.ctcpreply.\\(.*\\)\\'" event) - (circe-display-server-message - (format "CTCP %s reply from %s (%s)%s: %s" - (match-string 1 event) nick userhost target (cadr args)))) - ((string-match "\\`irc.ctcp.\\(.*\\)\\'" event) - (circe-display-server-message - (format "Unknown CTCP request %s from %s (%s)%s: %s" - (match-string 1 event) nick userhost target (cadr args)))) - (t - (circe-display-server-message - (format "[%s from %s%s] %s" - event - nick - (if userhost - (format " (%s)" userhost) - "") - (mapconcat #'identity args " ")))))))) - -(defun circe-set-display-handler (command handler) - "Set the display handler for COMMAND to HANDLER. - -A handler is either a function or a list. - -A function gets called in the server buffer with at least three -arguments, but possibly more. There's at least NICK and USERHOST -of the sender, which can be nil, and COMMAND, which is the event -which triggered this. Further arguments are arguments to the -event. - -Alternatively, the handler can be a list of two elements: - - target - The target of this message - format - The format for this string - -The target can be any of: - - 'active - The last active buffer of this server - 'nick - The nick who sent this message - 'server - The server buffer for this server - number - The index of the argument of the target - -The format is passed to `lui-format'. Possible format string -substitutions are {mynick}, {target}, {nick}, {userhost}, -{origin}, {command}, {target}, and indexed arguments for the -arguments to the IRC message." - (when (not circe-display-table) - (setq circe-display-table (make-hash-table :test 'equal))) - (puthash command handler circe-display-table)) - -(defun circe-get-display-handler (command) - "Return the display handler for COMMAND. - -See `circe-set-display-handler' for more information." - (when circe-display-table - (gethash command circe-display-table))) - -;;;;;;;;;;;;;;;; -;;; Commands ;;; -;;;;;;;;;;;;;;;; - -(defun circe-command-AWAY (reason) - "Set yourself away with REASON." - (interactive "sReason: ") - (irc-send-AWAY (circe-server-process) reason)) - -(defun circe-command-BACK (&optional ignored) - "Mark yourself not away anymore. - -Arguments are IGNORED." - (interactive) - (irc-send-AWAY (circe-server-process))) - -(defun circe-command-CHTOPIC (&optional ignored) - "Insert the topic of the current channel. - -Arguments are IGNORED." - (interactive) - (if (not circe-chat-target) - (circe-display-server-message "No target for current buffer") - (let* ((channel (irc-connection-channel (circe-server-process) - circe-chat-target)) - (topic (when channel - (irc-channel-topic channel)))) - (lui-replace-input (format "/TOPIC %s %s" - circe-chat-target (or topic "")))) - (goto-char (point-max)))) - -(defun circe-command-CLEAR (&optional ignored) - "Delete all buffer contents before the lui prompt." - (let ((inhibit-read-only t)) - (delete-region (point-min) lui-output-marker))) - -(defun circe-command-CTCP (who &optional command argument) - "Send a CTCP message to WHO containing COMMAND with ARGUMENT. -If COMMAND is not given, WHO is parsed to contain all of who, -command and argument. -If ARGUMENT is nil, it is interpreted as no argument." - (when (not command) - (if (string-match "^\\([^ ]*\\) *\\([^ ]*\\) *\\(.*\\)" who) - (setq command (upcase (match-string 2 who)) - argument (match-string 3 who) - who (match-string 1 who)) - (circe-display-server-message "Usage: /CTCP <who> <what>"))) - (when (not (string= "" command)) - (irc-send-ctcp (circe-server-process) - who - command - (if (and argument (not (equal argument ""))) - argument - nil)))) - -(defun circe-command-FOOL (line) - "Add the regex on LINE to the `circe-fool-list'." - (with-current-buffer (circe-server-last-active-buffer) - (cond - ((string-match "\\S-+" line) - (let ((regex (match-string 0 line))) - (add-to-list 'circe-fool-list regex) - (circe-display-server-message (format "Recognizing %s as a fool" - regex)))) - ((not circe-fool-list) - (circe-display-server-message "Your do not know any fools")) - (t - (circe-display-server-message "Your list of fools:") - (dolist (regex circe-fool-list) - (circe-display-server-message (format "- %s" regex))))))) - -(defun circe-command-GAWAY (reason) - "Set yourself away on all servers with reason REASON." - (interactive "sReason: ") - (dolist (buf (circe-server-buffers)) - (with-current-buffer buf - (irc-send-AWAY circe-server-process reason)))) - -(defun circe-command-GQUIT (reason) - "Quit all servers with reason REASON." - (interactive "sReason: ") - (dolist (buf (circe-server-buffers)) - (with-current-buffer buf - (when (eq (process-status circe-server-process) - 'open) - (irc-send-QUIT circe-server-process reason))))) - -(defun circe-command-HELP (&optional ignored) - "Display a list of recognized commands, nicely formatted." - (circe-display-server-message - (concat "Recognized commands are: " - (mapconcat (lambda (s) s) (circe--commands-list) "")))) - -(defun circe-command-IGNORE (line) - "Add the regex on LINE to the `circe-ignore-list'." - (with-current-buffer (circe-server-last-active-buffer) - (cond - ((string-match "\\S-+" line) - (let ((regex (match-string 0 line))) - (add-to-list 'circe-ignore-list regex) - (circe-display-server-message (format "Ignore list, meet %s" - regex)))) - ((not circe-ignore-list) - (circe-display-server-message "Your ignore list is empty")) - (t - (circe-display-server-message "Your ignore list:") - (dolist (regex circe-ignore-list) - (circe-display-server-message (format "- %s" regex))))))) - -(defun circe-command-INVITE (nick &optional channel) - "Invite NICK to CHANNEL. -When CHANNEL is not given, NICK is assumed to be a string -consisting of two words, the nick and the channel." - (interactive "sInvite who: \nsWhere: ") - (when (not channel) - (if (string-match "^\\([^ ]+\\) +\\([^ ]+\\)" nick) - (setq channel (match-string 2 nick) - nick (match-string 1 nick)) - (when (or (string= "" nick) (null nick)) - (circe-display-server-message "Usage: /INVITE <nick> <channel>")))) - (irc-send-INVITE (circe-server-process) - nick - (if (and (null channel) - (not (null nick))) - circe-chat-target - channel))) - -(defun circe-command-JOIN (channel) - "Join CHANNEL. This can also contain a key." - (interactive "sChannel: ") - (let (channels keys) - (when (string-match "^\\s-*\\([^ ]+\\)\\(:? \\([^ ]+\\)\\)?$" channel) - (setq channels (match-string 1 channel) - keys (match-string 3 channel)) - (dolist (channel (split-string channels ",")) - (pop-to-buffer - (circe-server-get-or-create-chat-buffer channel - 'circe-channel-mode))) - (irc-send-JOIN (circe-server-process) channels keys)))) - -(defun circe-command-ME (line) - "Send LINE to IRC as an action." - (interactive "sAction: ") - (if (not circe-chat-target) - (circe-display-server-message "No target for current buffer") - (circe-display 'circe-format-self-action - :body line - :nick (circe-nick)) - (irc-send-ctcp (circe-server-process) - circe-chat-target - "ACTION" line))) - -(defun circe-command-MSG (who &optional what) - "Send a message. - -Send WHO a message containing WHAT. - -If WHAT is not given, WHO should contain both the nick and the -message separated by a space." - (when (not what) - (if (string-match "^\\([^ ]*\\) \\(.*\\)" who) - (setq what (match-string 2 who) - who (match-string 1 who)) - (circe-display-server-message "Usage: /MSG <who> <what>"))) - (when what - (let ((buf (circe-query-auto-query-buffer who))) - (if buf - (with-current-buffer buf - (circe-command-SAY what) - (lui-add-input what)) - (with-current-buffer (circe-server-last-active-buffer) - (irc-send-PRIVMSG (circe-server-process) - who what) - (circe-display 'circe-format-self-message - :target who - :body what)))))) - -(defun circe-command-NAMES (&optional channel) - "List the names of the current channel or CHANNEL." - (interactive) - (let ((target (when channel - (string-trim channel)))) - (when (or (not target) - (equal target "")) - (setq target circe-chat-target)) - (if (not target) - (circe-display-server-message "No target for current buffer") - (irc-send-NAMES (circe-server-process) - target)))) - -(defun circe-command-NICK (newnick) - "Change nick to NEWNICK." - (interactive "sNew nick: ") - (let ((newnick (string-trim newnick))) - (irc-send-NICK (circe-server-process) newnick))) - -(defun circe-command-PART (reason) - "Part the current channel because of REASON." - (interactive "sReason: ") - (if (not circe-chat-target) - (circe-display-server-message "No target for current buffer") - (irc-send-PART (circe-server-process) - circe-chat-target - (if (equal "" reason) - circe-default-part-message - reason)))) - -(defun circe-command-PING (target) - "Send a CTCP PING request to TARGET." - (interactive "sWho: ") - (let ((target (string-trim target))) - (irc-send-ctcp (circe-server-process) - target - "PING" (format "%s" (float-time))))) - -(defun circe-command-QUERY (arg) - "Open a query with WHO." - ;; Eventually, this should probably be just the same as - ;; circe-command-MSG - (interactive "sQuery with: ") - (let* (who what) - (if (string-match "\\`\\s-*\\(\\S-+\\)\\s-\\(\\s-*\\S-.*\\)\\'" arg) - (setq who (match-string 1 arg) - what (match-string 2 arg)) - (setq who (string-trim arg))) - (when (string= who "") - (circe-display-server-message "Usage: /query <nick> [something to say]")) - (pop-to-buffer - (circe-server-get-or-create-chat-buffer who 'circe-query-mode)) - (when what - (circe-command-SAY what) - (lui-add-input what)))) - -(defun circe-command-QUIT (reason) - "Quit the current server giving REASON." - (interactive "sReason: ") - (with-circe-server-buffer - (setq circe-server-inhibit-auto-reconnect-p t) - (irc-send-QUIT (circe-server-process) - (if (equal "" reason) - circe-default-quit-message - reason)))) - -(defun circe-command-QUOTE (line) - "Send LINE verbatim to the server." - (interactive "Line: ") - (irc-send-raw (circe-server-process) line) - (with-current-buffer (circe-server-last-active-buffer) - (circe-display-server-message (format "Sent to server: %s" - line)))) - -(defun circe-command-SAY (line) - "Say LINE to the current target." - (interactive "sSay: ") - (if (not circe-chat-target) - (circe-display-server-message "No target for current buffer") - (dolist (line (circe--split-line line)) - (circe-display 'circe-format-self-say - :body line - :nick (circe-nick)) - (irc-send-PRIVMSG (circe-server-process) - circe-chat-target - ;; Some IRC servers give an error if there is - ;; no text at all. - (if (string= line "") - " " - line))))) - -(defun circe--split-line (longline) - "Splits LONGLINE into smaller components. - -IRC silently truncates long lines. This splits a long line into -parts that each are not longer than `circe-split-line-length'." - (if (< (length longline) - circe-split-line-length) - (list longline) - (with-temp-buffer - (insert longline) - (let ((fill-column circe-split-line-length)) - (fill-region (point-min) (point-max) - nil t)) - (split-string (buffer-string) "\n")))) - -(defun circe-command-SV (&optional ignored) - "Tell the current channel about your client and Emacs version. - -Arguments are IGNORED." - (interactive) - (circe-command-SAY (format (concat "I'm using Circe version %s " - "with %s %s (of %s)") - (circe--version) - "GNU Emacs" - emacs-version - (format-time-string "%Y-%m-%d" - emacs-build-time)))) - -(defun circe-command-TOPIC (channel &optional newtopic) - "Change the topic of CHANNEL to NEWTOPIC." - (interactive "sChannel: \nsNew topic: ") - (when (string-match "^\\s-*$" channel) - (setq channel nil)) - (when (and channel - (not newtopic) - (string-match "^\\s-*\\(\\S-+\\)\\( \\(.*\\)\\)?" channel)) - (setq newtopic (match-string 3 channel) - channel (match-string 1 channel))) - (cond - ((and channel newtopic) - (irc-send-TOPIC (circe-server-process) channel newtopic)) - (channel - (irc-send-TOPIC (circe-server-process) channel)) - (circe-chat-target - (irc-send-TOPIC (circe-server-process) circe-chat-target)) - (t - (circe-display-server-message "No channel given, and no default target.")))) - -(defun circe-command-UNFOOL (line) - "Remove the entry LINE from `circe-fool-list'." - (with-current-buffer (circe-server-last-active-buffer) - (cond - ((string-match "\\S-+" line) - (let ((regex (match-string 0 line))) - (setq circe-fool-list (delete regex circe-fool-list)) - (circe-display-server-message (format "Assuming %s is not a fool anymore" - regex)))) - (t - (circe-display-server-message - "No one is not a fool anymore? UNFOOL requires one argument"))))) - -(defun circe-command-UNIGNORE (line) - "Remove the entry LINE from `circe-ignore-list'." - (with-current-buffer (circe-server-last-active-buffer) - (cond - ((string-match "\\S-+" line) - (let ((regex (match-string 0 line))) - (setq circe-ignore-list (delete regex circe-ignore-list)) - (circe-display-server-message (format "Ignore list forgot about %s" - regex)))) - (t - (circe-display-server-message - "Who do you want to unignore? UNIGNORE requires one argument"))))) - -(defun circe-command-WHOAMI (&optional ignored) - "Request WHOIS information about yourself. - -Arguments are IGNORED." - (interactive) - (irc-send-WHOIS (circe-server-process) - (circe-nick))) - -(defun circe-command-WHOIS (whom) - "Request WHOIS information about WHOM." - (interactive "sWhois: ") - (let* ((whom-server-name (split-string whom)) - (whom (car whom-server-name)) - (server-or-name (cadr whom-server-name))) - (irc-send-WHOIS (circe-server-process) whom server-or-name))) - -(defun circe-command-WHOWAS (whom) - "Request WHOWAS information about WHOM." - (interactive "sWhois: ") - (let ((whom (string-trim whom))) - (irc-send-WHOWAS (circe-server-process) whom))) - -(defun circe-command-STATS (query) - "Request statistics from a server." - (interactive) - ;; Split string into query and server if we can - (let ((query (split-string query))) - (irc-send-STATS (circe-server-process) (car query) (cadr query)))) - -(defun circe-command-WL (&optional split) - "Show the people who left in a netsplit. -Without any arguments, shows shows the current netsplits and how -many people are missing. With an argument SPLIT, which must be a -number, it shows the missing people due to that split." - (let ((circe-netsplit-list (with-circe-server-buffer - circe-netsplit-list))) - (if (or (not split) - (and (stringp split) - (string= split ""))) - (if (null circe-netsplit-list) - (circe-display-server-message "No net split at the moment") - (let ((n 0)) - (dolist (entry circe-netsplit-list) - (circe-display-server-message (format "(%d) Missing %d people due to %s" - n - (hash-table-count (nth 3 entry)) - (car entry))) - (setq n (+ n 1))))) - (let* ((index (if (numberp split) - split - (string-to-number split))) - (entry (nth index circe-netsplit-list))) - (if (not entry) - (circe-display-server-message (format "No split number %s - use /WL to see a list" - split)) - (let ((missing nil)) - (maphash (lambda (_key value) - (setq missing (cons value missing))) - (nth 3 entry)) - (circe-display-server-message - (format "Missing people due to %s: %s" - (car entry) - (mapconcat 'identity - (sort missing - (lambda (a b) - (string< (downcase a) - (downcase b)))) - ", "))))))))) - -;;;;;;;;;;;;;;;;;;;;;;;; -;;; Display Handlers ;;; -;;;;;;;;;;;;;;;;;;;;;;;; - -(defun circe-display-ignore (_nick _userhost _command &rest _args) - "Don't show a this message. - -NICK and USERHOST are the originator of COMMAND which had ARGS as -arguments." - 'noop) - -(circe-set-display-handler "317" 'circe-display-317) -(defun circe-display-317 (_sender ignored _numeric _target nick - idletime &optional signon-time body) - "Show a 317 numeric (RPL_WHOISIDLE). - -Arguments are either of the two: - -:<server> 317 <ournick> <nick> <idle> :seconds idle -:<server> 317 <ournick> <nick> <idle> <signon> :seconds idle, signon time" - (with-current-buffer (circe-server-last-active-buffer) - (let ((seconds-idle (string-to-number idletime)) - (signon-time (when body - (string-to-number signon-time)))) - (if signon-time - (circe-display 'circe-format-server-whois-idle-with-signon - :whois-nick nick - :idle-seconds seconds-idle - :idle-duration (circe-duration-string seconds-idle) - :signon-time signon-time - :signon-date (current-time-string - (seconds-to-time signon-time)) - :signon-ago (circe-duration-string (- (float-time) - signon-time))) - (circe-display 'circe-format-server-whois-idle - :whois-nick nick - :idle-seconds seconds-idle - :idle-duration (circe-duration-string seconds-idle)))))) - -(circe-set-display-handler "329" 'circe-display-329) -(defun circe-display-329 (_server ignored _numeric _target channel timestamp) - "Show a 329 numeric (RPL_CREATIONTIME)." - (with-current-buffer (or (circe-server-get-chat-buffer channel) - (circe-server-last-active-buffer)) - (let ((creation-time (string-to-number timestamp))) - (circe-display 'circe-format-server-channel-creation-time - :channel channel - :date (current-time-string - (seconds-to-time creation-time)) - :ago (circe-duration-string (- (float-time) - creation-time)))))) - -(circe-set-display-handler "333" 'circe-display-333) -(defun circe-display-333 (_server ignored _numeric target - channel setter topic-time) - "Show a 333 numeric (RPL_TOPICWHOTIME). - -Arguments are either of the two: - -:<server> 333 <target> <channel> <nick> 1434996762 -:<server> 333 <target> <channel> <nick>!<user>@<host> 1434996803" - (let ((channel-buffer (circe-server-get-chat-buffer channel)) - (topic-time (string-to-number topic-time))) - (with-current-buffer (or channel-buffer - (circe-server-last-active-buffer)) - (circe-display (if channel-buffer - 'circe-format-server-topic-time - 'circe-format-server-topic-time-for-channel) - :nick target - :channel channel - :setter (irc-userstring-nick setter) - :setter-userhost (or (irc-userstring-userhost setter) - "(unknown)") - :topic-time topic-time - :topic-date (current-time-string - (seconds-to-time topic-time)) - :topic-ago (circe-duration-string (- (float-time) - topic-time)))))) - -(circe-set-display-handler "AUTHENTICATE" 'circe-display-ignore) -(circe-set-display-handler "CAP" 'circe-display-ignore) -(circe-set-display-handler "conn.connected" 'circe-display-ignore) -(circe-set-display-handler "conn.disconnected" 'circe-display-ignore) - -(circe-set-display-handler "irc.ctcp" 'circe-display-ignore) -(circe-set-display-handler "irc.ctcpreply" 'circe-display-ignore) - -(circe-set-display-handler "irc.ctcp.ACTION" 'circe-display-ctcp-action) -(defun circe-display-ctcp-action (nick userhost _command target text) - "Show an ACTION." - (cond - ;; Query - ((circe-server-my-nick-p target) - (let ((query-buffer (circe-query-auto-query-buffer nick))) - (with-current-buffer (or query-buffer - (circe-server-last-active-buffer)) - (circe-display (if query-buffer - 'circe-format-action - 'circe-format-message-action) - :nick nick - :userhost (or userhost "server") - :body text)))) - ;; Channel - (t - (with-current-buffer (circe-server-get-or-create-chat-buffer - target 'circe-channel-mode) - (circe-lurker-display-active nick userhost) - (circe-display 'circe-format-action - :nick nick - :userhost (or userhost "server") - :body text))))) - -(circe-set-display-handler "irc.ctcp.CLIENTINFO" 'circe-display-ctcp) - -(circe-set-display-handler "irc.ctcp.PING" 'circe-display-ctcp-ping) -(defun circe-display-ctcp-ping (nick userhost _command target text) - "Show a CTCP PING request." - (with-current-buffer (circe-server-last-active-buffer) - (circe-display 'circe-format-server-ctcp-ping - :nick nick - :userhost (or userhost "server") - :target target - :body (or text "") - :ago (let ((time (when text - (string-to-number text)))) - (if time - (format "%.2f seconds" (- (float-time) time)) - "unknown seconds"))))) - -(circe-set-display-handler "irc.ctcpreply.PING" 'circe-display-ctcp-ping-reply) -(defun circe-display-ctcp-ping-reply (nick userhost _command target text) - "Show a CTCP PING reply." - (with-current-buffer (circe-server-last-active-buffer) - (circe-display 'circe-format-server-ctcp-ping-reply - :nick nick - :userhost (or userhost "server") - :target target - :body text - :ago (let ((time (string-to-number text))) - (if time - (format "%.2f seconds" (- (float-time) time)) - "unknown seconds"))))) - -(circe-set-display-handler "irc.ctcp.SOURCE" 'circe-display-ctcp) -(circe-set-display-handler "irc.ctcp.TIME" 'circe-display-ctcp) -(circe-set-display-handler "irc.ctcp.VERSION" 'circe-display-ctcp) -(defun circe-display-ctcp (nick userhost command target text) - "Show a CTCP request that does not require special handling." - (with-current-buffer (circe-server-last-active-buffer) - (circe-display 'circe-format-server-ctcp - :nick nick - :userhost (or userhost "server") - :target target - :command (substring command 9) - :body (or text "")))) - -(circe-set-display-handler "irc.registered" 'circe-display-ignore) - -(circe-set-display-handler "JOIN" 'circe-display-JOIN) -(defun circe-display-JOIN (nick userhost _command channel - &optional accountname realname) - "Show a JOIN message. - -The command receives an extra argument, the account name, on some -IRC servers." - (let* ((accountname (if (equal accountname "*") - "(unauthenticated)" - accountname)) - (userinfo (if accountname - (format "%s, %s: %s" userhost accountname realname) - userhost)) - (split (circe--netsplit-join nick))) - ;; First, update the channel - (with-current-buffer (circe-server-get-or-create-chat-buffer - channel 'circe-channel-mode) - (cond - (split - (let ((split-time (cadr split))) - (when (< (+ split-time circe-netsplit-delay) - (float-time)) - (circe-display 'circe-format-server-netmerge - :split (car split) - :time (cadr split) - :date (current-time-string - (seconds-to-time (cadr split))) - :ago (circe-duration-string - (- (float-time) (cadr split))))))) - ((and (circe-reduce-lurker-spam) - (circe-lurker-rejoin-p nick circe-chat-target)) - (let* ((channel (irc-connection-channel (circe-server-process) - circe-chat-target)) - (user (when channel - (irc-channel-recent-user channel nick))) - (departed (when user - (irc-user-part-time user)))) - (circe-display 'circe-format-server-rejoin - :nick nick - :userhost (or userhost "server") - :accountname accountname - :realname realname - :userinfo userinfo - :departuretime departed - :departuredelta (circe-duration-string - (- (float-time) - departed))))) - ((not (circe-reduce-lurker-spam)) - (circe-display 'circe-format-server-join - :nick nick - :userhost (or userhost "server") - :accountname accountname - :realname realname - :userinfo userinfo - :channel circe-chat-target)))) - ;; Next, a possible query buffer. We do this even when the message - ;; should be ignored by a netsplit, since this can't flood. - (let ((buf (circe-server-get-chat-buffer nick))) - (when buf - (with-current-buffer buf - (circe-display 'circe-format-server-join-in-channel - :nick nick - :userhost (or userhost "server") - :accountname accountname - :realname realname - :userinfo userinfo - :channel circe-chat-target)))))) - -(circe-set-display-handler "MODE" 'circe-display-MODE) -(defun circe-display-MODE (setter userhost _command target &rest modes) - "Show a MODE message." - (with-current-buffer (or (circe-server-get-chat-buffer target) - (circe-server-last-active-buffer)) - (circe-display 'circe-format-server-mode-change - :setter setter - :userhost (or userhost "server") - :target target - :change (mapconcat #'identity modes " ")))) - -(circe-set-display-handler "NICK" 'circe-display-NICK) -(defun circe-display-NICK (old-nick userhost _command new-nick) - "Show a nick change." - (if (circe-server-my-nick-p new-nick) - (dolist (buf (cons (or circe-server-buffer - (current-buffer)) - (circe-server-chat-buffers))) - (with-current-buffer buf - (circe-display 'circe-format-server-nick-change-self - :old-nick old-nick - :userhost (or userhost "server") - :new-nick new-nick))) - (let ((query-buffer (circe-server-get-chat-buffer old-nick))) - (when query-buffer - (with-current-buffer query-buffer - (circe-server-rename-chat-buffer old-nick new-nick) - (circe-display 'circe-format-server-nick-change - :old-nick old-nick - :new-nick new-nick - :userhost (or userhost "server"))))) - (dolist (buf (circe-user-channels new-nick)) - (with-current-buffer buf - (cond - ((and (circe-reduce-lurker-spam) - (circe-lurker-p new-nick)) - nil) - ((circe-channel-user-nick-regain-p old-nick new-nick) - (circe-display 'circe-format-server-nick-regain - :old-nick old-nick - :new-nick new-nick - :userhost (or userhost "server"))) - (t - (circe-display 'circe-format-server-nick-change - :old-nick old-nick - :new-nick new-nick - :userhost (or userhost "server")))))))) - -(circe-set-display-handler "nickserv.identified" 'circe-display-ignore) - -;; NOTICE is also used to encode CTCP replies. irc.el will send -;; irc.notice events for NOTICEs without CTCP replies, so we show -;; that, not the raw notice. -(circe-set-display-handler "NOTICE" 'circe-display-ignore) -(circe-set-display-handler "irc.notice" 'circe-display-NOTICE) -(defun circe-display-NOTICE (nick userhost _command target text) - "Show a NOTICE message." - (cond - ((not userhost) - (with-current-buffer (circe-server-last-active-buffer) - (circe-display 'circe-format-server-notice - :server nick - :body text))) - ((circe-server-my-nick-p target) - (with-current-buffer (or (circe-server-get-chat-buffer nick) - (circe-server-last-active-buffer)) - (circe-display 'circe-format-notice - :nick nick - :userhost (or userhost "server") - :body text))) - (t - (with-current-buffer (or (circe-server-get-chat-buffer target) - (circe-server-last-active-buffer)) - (circe-display 'circe-format-notice - :nick nick - :userhost (or userhost "server") - :body text))))) - -(circe-set-display-handler "PART" 'circe-display-PART) -(defun circe-display-PART (nick userhost _command channel &optional reason) - "Show a PART message." - (with-current-buffer (or (circe-server-get-chat-buffer channel) - (circe-server-last-active-buffer)) - (when (or (not circe-chat-target) - (not (circe-lurker-p nick))) - (circe-display 'circe-format-server-part - :nick nick - :userhost (or userhost "server") - :channel channel - :reason (or reason "[No reason given]"))))) - -(circe-set-display-handler "PING" 'circe-display-ignore) -(circe-set-display-handler "PONG" 'circe-display-ignore) - -;; PRIVMSG is also used to encode CTCP requests. irc.el will send -;; irc.message events for PRIVMSGs without CTCP messages, so we show -;; that, not the raw message. -(circe-set-display-handler "PRIVMSG" 'circe-display-ignore) -(circe-set-display-handler "irc.message" 'circe-display-PRIVMSG) -(defun circe-display-PRIVMSG (nick userhost _command target text) - "Show a PRIVMSG message." - (cond - ((circe-server-my-nick-p target) - (let ((buf (circe-query-auto-query-buffer nick))) - (if buf - (with-current-buffer buf - (circe-display 'circe-format-say - :nick nick - :userhost (or userhost "server") - :body text)) - (with-current-buffer (circe-server-last-active-buffer) - (circe-display 'circe-format-message - :nick nick - :userhost (or userhost "server") - :body text))))) - (t - (with-current-buffer (circe-server-get-or-create-chat-buffer - target 'circe-channel-mode) - (circe-lurker-display-active nick userhost) - (circe-display 'circe-format-say - :nick nick - :userhost (or userhost "server") - :body text))))) - -(circe-set-display-handler "TOPIC" 'circe-display-topic) -(defun circe-display-topic (nick userhost _command channel new-topic) - "Show a TOPIC change." - (with-current-buffer (circe-server-get-or-create-chat-buffer - channel 'circe-channel-mode) - (let* ((channel-obj (irc-connection-channel (circe-server-process) - channel)) - (old-topic (or (when channel - (irc-channel-last-topic channel-obj)) - ""))) - (circe-display 'circe-format-server-topic - :nick nick - :userhost (or userhost "server") - :channel channel - :new-topic new-topic - :old-topic old-topic - :topic-diff (circe--topic-diff old-topic new-topic))))) - -(defun circe--topic-diff (old new) - "Return a colored topic diff between OLD and NEW." - (mapconcat (lambda (elt) - (cond - ((eq '+ (car elt)) - (let ((s (cadr elt))) - (add-face-text-property 0 (length s) - 'circe-topic-diff-new-face nil s) - s)) - ((eq '- (car elt)) - (let ((s (cadr elt))) - (add-face-text-property 0 (length s) - 'circe-topic-diff-removed-face nil s) - s)) - (t - (cadr elt)))) - (lcs-unified-diff (circe--topic-diff-split old) - (circe--topic-diff-split new) - 'string=) - "")) - -(defun circe--topic-diff-split (str) - "Split STR into a list of components. -The list consists of words and spaces." - (let ((lis nil)) - (with-temp-buffer - (insert str) - (goto-char (point-min)) - (while (< (point) - (point-max)) - (if (or (looking-at "\\w+\\W*") - (looking-at ".\\s-*")) - (progn - (setq lis (cons (match-string 0) - lis)) - (replace-match "")) - (error "Can't happen")))) - (nreverse lis))) - -(circe-set-display-handler "channel.quit" 'circe-display-channel-quit) -(defun circe-display-channel-quit (nick userhost _command channel - &optional reason) - "Show a QUIT message." - (let ((split (circe--netsplit-quit reason nick))) - (with-current-buffer (circe-server-get-or-create-chat-buffer - channel 'circe-channel-mode) - (cond - (split - (when (< (+ split circe-netsplit-delay) - (float-time)) - (circe-display 'circe-format-server-netsplit - :split reason))) - ((not (circe-lurker-p nick)) - (circe-display 'circe-format-server-quit-channel - :nick nick - :userhost (or userhost "server") - :channel channel - :reason (or reason "[no reason given]"))))))) - -(circe-set-display-handler "QUIT" 'circe-display-QUIT) -(defun circe-display-QUIT (nick userhost _command &optional reason) - "Show a QUIT message. - -Channel quits are shown already, so just show quits in queries." - (let ((buf (circe-server-get-chat-buffer nick))) - (when buf - (with-current-buffer buf - (circe-display 'circe-format-server-quit - :nick nick - :userhost (or userhost "server") - :reason (or reason "[no reason given]")))))) - -(defvar circe-netsplit-list nil - "A list of recorded netsplits. -Every item is a list with four elements: -- The quit message for this split. -- The time when last we heard about a join in this split -- The time when last we heard about a quit in this split -- A hash table noting which nicks did leave") -(make-variable-buffer-local 'circe-netsplit-list) - -(defun circe--netsplit-join (nick) - "Search for NICK in the netsplit lists. -This either returns a pair whose car is the quit message of this -split, and the cadr the time we last heard anything of the split -of that user. If the NICK isn't split, this returns nil." - (with-circe-server-buffer - (catch 'return - (dolist (entry circe-netsplit-list) - (let ((table (nth 3 entry))) - (when (gethash nick table) - (let ((name (nth 0 entry)) - (time (nth 1 entry))) - (remhash nick table) - (when (= 0 (hash-table-count table)) - (setq circe-netsplit-list - (delq entry circe-netsplit-list))) - (setcar (cdr entry) - (float-time)) - (throw 'return (list name time)))))) - nil))) - -(defun circe--netsplit-quit (reason nick) - "If REASON indicates a netsplit, mark NICK as splitted. -This either returns the time when last we heard about this split, -or nil when this isn't a split." - (when (circe--netsplit-reason-p reason) - (with-circe-server-buffer - (let ((entry (assoc reason circe-netsplit-list))) - (if entry - (let ((time (nth 2 entry)) - (table (nth 3 entry))) - (setcar (cddr entry) - (float-time)) - (puthash nick nick table) - time) - ;; New split! - (let ((table (make-hash-table :test 'equal))) - (puthash nick nick table) - (setq circe-netsplit-list - (cons (list reason 0 (float-time) table) - circe-netsplit-list)) - 0)))))) - -(defun circe--netsplit-reason-p (reason) - "Return non-nil if REASON is the quit message of a netsplit. -This is true when it contains exactly two hosts, with a single -space in between them. The hosts must include at least one dot, -and must not include colons or slashes (else they might be -URLs). (Thanks to irssi for this criteria list)" - (if (string-match "^[^ :/]+\\.[^ :/]* [^ :/]+\\.[^ :/]*$" - reason) - t - nil)) - -(let ((simple-format-specifiers - '(("INVITE" active "Invite: {origin} invites you to {1}") - ("KICK" 0 "Kick: {1} kicked by {origin}: {2}") - ("ERROR" active "Error: {0-}") - ("001" server "{1}") - ("002" server "{1}") - ("003" server "{1}") - ("004" server "{1-}") - ("005" server "{1-}") - ;; IRCnet: * Please wait while we process your connection. - ("020" server "{0-}") - ;; IRCnet - ("042" server "Your unique ID is {1}") - ("200" active "{1-}") - ("201" active "{1-}") - ("203" active "{1-}") - ("204" active "{1-}") - ("205" active "{1-}") - ("206" active "{1-}") - ("207" active "{1-}") - ("208" active "{1-}") - ("209" active "{1-}") - ("211" active "{1-}") - ("212" active "{1-}") - ("219" active "{1-}") - ("221" active "User mode: {1-}") - ("234" active "Service: {1-}") - ("235" active "{1-}") - ("242" active "{1}") - ("243" active "{1-}") - ("250" server "{1}") - ("251" server "{1}") - ("252" server "{1-}") - ("253" server "{1-}") - ("254" server "{1-}") - ("255" server "{1}") - ("256" active "{1-}") - ("257" active "{1}") - ("258" active "{1}") - ("259" active "{1}") - ("261" active "{1-}") - ("262" active "{1-}") - ("263" active "{1-}") - ("265" server "{1-}") - ("266" server "{1-}") - ;; This is returned on both WHOIS and PRIVMSG. It - ;; should go to the active window for the former, and - ;; the query window for the latter. Oh well. - ("301" active "User away: {1}") - ("302" active "User hosts: {1}") - ("303" active "Users online: {1}") - ("305" active "{1}") - ("306" active "{1}") - ("307" active "{1-}") - ;; Coldfront: 310 <nick> is available for help. - ("310" active "{1-}") - ("311" active "{1} is {2}@{3} ({5})") - ("312" active "{1} is on {2} ({3})") - ("313" active "{1} {2}") - ("314" active "{1} was {2}@{3} ({5})") - ("315" active "{2}") - ("318" active "{2}") - ("319" active "{1} is on {2}") - ("320" active "{1-}") - ("322" active "{1-}") - ("323" active "{1-}") - ("324" 1 "Channel mode for {1}: {2-}") - ("325" 1 "Unique operator on {1} is {2}") - ("328" 1 "Channel homepage for {1}: {2-}") - ("330" active "{1} is logged in as {2}") - ("331" 1 "No topic for {1} set") - ("332" 1 "Topic for {1}: {2}") - ("341" active "Inviting {1} to {2}") - ("346" 1 "Invite mask: {2}") - ("347" 1 "{2}") - ("348" 1 "Except mask: {2}") - ("349" 1 "{2}") - ("351" active "{1-}") - ("352" active "{5} ({2}@{3}) in {1} on {4}: {6-}") - ("353" 2 "Names: {3}") - ("364" active "{1-}") - ("365" active "{1-}") - ("366" 1 "{2}") - ("367" 1 "Ban mask: {2}") - ("368" 1 "{2}") - ("369" active "{1} {2}") - ("371" active "{1}") - ("372" server "{1}") - ("374" active "{1}") - ("375" server "{1}") - ("376" server "{1}") - ("378" active "{1-}") - ("381" active "{1}") - ("382" active "{1-}") - ("391" active "Time on {1}: {2}") - ("401" active "No such nick: {1}") - ("402" active "No such server: {1}") - ("403" active "No such channel: {1}") - ("404" 1 "Can not send to channel {1}") - ("405" active "Can not join {1}: {2}") - ("406" active "{1-}") - ("407" active "{1-}") - ("408" active "No such service: {1}") - ("422" active "{1}") - ("432" active "Erroneous nick name: {1}") - ("433" active "Nick name in use: {1}") - ("437" active "Nick/channel is temporarily unavailable: {1}") - ("441" 2 "User not on channel: {1}") - ("442" active "You are not on {1}") - ("443" 2 "User {1} is already on channel {2}") - ;; Coldfront: 451 * :You have not registered - ("451" active "{1-}") - ("467" 1 "{2}") - ("470" 1 "{1} made you join {2}: {3-}") - ("471" 1 "{2}") - ("472" active "{1-}") - ("473" active "{1-}") - ("474" active "{1-}") - ("475" active "{1-}") - ("476" active "{1-}") - ("477" active "{1-}") - ("481" 1 "{2-}") - ("484" active "{1-}") - ;; Coldfront: 671 <nick> is using a Secure Connection - ("671" active "{1-}") - ("728" 1 "Quiet mask: {3}") - ("729" 1 "{3-}") - ;; Freenode SASL auth - ("900" active "SASL: {3-}") - ("903" active "{1-}")))) - (dolist (fmt simple-format-specifiers) - (circe-set-display-handler (car fmt) (cdr fmt)))) - -(defun circe-set-message-target (command target) - "Set the target of COMMAND to TARGET. - -This can be used to change format-based display handlers more -easily." - (let ((handler (circe-get-display-handler command))) - (when (not (consp handler)) - (error "Handler of command %s is not a list" command)) - (setcar handler target))) - -;;;;;;;;;;;;;;;;;;;;;;;; -;;; Helper Functions ;;; -;;;;;;;;;;;;;;;;;;;;;;;; - -(defun circe--list-drop-right (list pattern) - "Drop elements from the right of LIST that match PATTERN. - -LIST should be a list of strings, and PATTERN is used as a -regular expression." - (let ((list (reverse list))) - (while (and list - (string-match pattern (car list))) - (setq list (cdr list))) - (nreverse list))) - -(defun circe--nick-next (oldnick) - "Return a new nick to try for OLDNICK." - (cond - ;; If the nick ends with -+, replace those with _ - ((string-match "^\\(.*[^-]\\)\\(-+\\)$" oldnick) - (concat (match-string 1 oldnick) - (make-string (- (match-end 2) - (match-beginning 2)) - ?_))) - ;; If the nick is 9 chars long, take prefix and rotate. - ((>= (length oldnick) - 9) - (when (string-match "^\\(.*[^-_]\\)[-_]*$" oldnick) - (let ((nick (match-string 1 oldnick))) - (concat (substring nick 1) - (string (aref nick 0)))))) - ;; If the nick ends with _+ replace those with - and add one - ((string-match "^\\(.*[^_]\\)\\(_+\\)$" oldnick) - (concat (match-string 1 oldnick) - (make-string (- (match-end 2) - (match-beginning 2)) - ?-) - "-")) - ;; Else, just append - - (t - (concat oldnick "-")))) - -(defun circe-duration-string (duration) - "Return a description of a DURATION in seconds." - (let ((parts `((,(* 12 30 24 60 60) "year") - (,(* 30 24 60 60) "month") - (,(* 24 60 60) "day") - (,(* 60 60) "hour") - (60 "minute") - (1 "second"))) - (duration (round duration)) - (result nil)) - (dolist (part parts) - (let* ((seconds-per-part (car part)) - (description (cadr part)) - (count (/ duration seconds-per-part))) - (when (not (zerop count)) - (setq result (cons (format "%d %s%s" - count description - (if (= count 1) "" "s")) - result))) - (setq duration (- duration (* count seconds-per-part))))) - (if result - (mapconcat #'identity - (nreverse result) - " ") - "a moment"))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Deprecated functions and variables - -(define-obsolete-function-alias 'circe-server-nick 'circe-nick - "Circe 2.0") - -(define-obsolete-function-alias 'circe-server-message - 'circe-display-server-message - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-networks 'circe-network-defaults - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-name 'circe-host - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-service 'circe-port - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-network 'circe-network - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-ip-family 'circe-ip-family - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-nick 'circe-nick - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-user 'circe-user - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-pass 'circe-pass - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-realname 'circe-realname - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-use-tls 'circe-use-tls - "Circe 2.0") - -(define-obsolete-variable-alias 'circe-server-auto-join-channels - 'circe-channels - "Circe 2.0") - -(provide 'circe) -;;; circe.el ends here |