The SSH host key has changed on 8 April, 2022 to this one: SHA256:573uTBSeh74kvOo0HJXi5ijdzRm8me27suzNEDlGyrQ

Install some packages

gerrit-package
Gergely Polonkai 6 years ago
parent d07a7938ad
commit d3a2edb4d4
  1. 92
      elpa/alert-20160824.821/alert-autoloads.el
  2. 2
      elpa/alert-20160824.821/alert-pkg.el
  3. 1045
      elpa/alert-20160824.821/alert.el
  4. 225
      elpa/circe-20160608.1315/circe-autoloads.el
  5. 97
      elpa/circe-20160608.1315/circe-chanop.el
  6. 345
      elpa/circe-20160608.1315/circe-color-nicks.el
  7. 53
      elpa/circe-20160608.1315/circe-compat.el
  8. 100
      elpa/circe-20160608.1315/circe-highlight-all-nicks.el
  9. 243
      elpa/circe-20160608.1315/circe-lagmon.el
  10. 86
      elpa/circe-20160608.1315/circe-new-day-notifier.el
  11. 6
      elpa/circe-20160608.1315/circe-pkg.el
  12. 3586
      elpa/circe-20160608.1315/circe.el
  13. 1406
      elpa/circe-20160608.1315/irc.el
  14. 202
      elpa/circe-20160608.1315/lcs.el
  15. 115
      elpa/circe-20160608.1315/lui-autopaste.el
  16. 198
      elpa/circe-20160608.1315/lui-format.el
  17. 182
      elpa/circe-20160608.1315/lui-irc-colors.el
  18. 201
      elpa/circe-20160608.1315/lui-logging.el
  19. 110
      elpa/circe-20160608.1315/lui-track-bar.el
  20. 1353
      elpa/circe-20160608.1315/lui.el
  21. 194
      elpa/circe-20160608.1315/make-tls-process.el
  22. 223
      elpa/circe-20160608.1315/shorten.el
  23. 391
      elpa/circe-20160608.1315/tracking.el
  24. 26
      elpa/emojify-20160928.550/data/emoji-sets.json
  25. 31306
      elpa/emojify-20160928.550/data/emoji.json
  26. 68
      elpa/emojify-20160928.550/emojify-autoloads.el
  27. 9
      elpa/emojify-20160928.550/emojify-pkg.el
  28. 1571
      elpa/emojify-20160928.550/emojify.el
  29. 22
      elpa/gntp-20141024.1950/gntp-autoloads.el
  30. 2
      elpa/gntp-20141024.1950/gntp-pkg.el
  31. 243
      elpa/gntp-20141024.1950/gntp.el
  32. 15
      elpa/ht-20161015.1945/ht-autoloads.el
  33. 2
      elpa/ht-20161015.1945/ht-pkg.el
  34. 288
      elpa/ht-20161015.1945/ht.el
  35. 15
      elpa/log4e-20150105.505/log4e-autoloads.el
  36. 2
      elpa/log4e-20150105.505/log4e-pkg.el
  37. 590
      elpa/log4e-20150105.505/log4e.el
  38. 45
      elpa/oauth2-0.11/oauth2-autoloads.el
  39. 2
      elpa/oauth2-0.11/oauth2-pkg.el
  40. 342
      elpa/oauth2-0.11/oauth2.el
  41. 38
      elpa/org-jekyll-20130508.239/org-jekyll-autoloads.el
  42. 2
      elpa/org-jekyll-20130508.239/org-jekyll-pkg.el
  43. 257
      elpa/org-jekyll-20130508.239/org-jekyll.el
  44. 39
      elpa/org-random-todo-20160208.426/org-random-todo-autoloads.el
  45. 2
      elpa/org-random-todo-20160208.426/org-random-todo-pkg.el
  46. 148
      elpa/org-random-todo-20160208.426/org-random-todo.el
  47. 15
      elpa/org-rtm-20160214.436/org-rtm-autoloads.el
  48. 2
      elpa/org-rtm-20160214.436/org-rtm-pkg.el
  49. 140
      elpa/org-rtm-20160214.436/org-rtm.el
  50. 15
      elpa/request-20160822.1659/request-autoloads.el
  51. 2
      elpa/request-20160822.1659/request-pkg.el
  52. 1297
      elpa/request-20160822.1659/request.el
  53. 15
      elpa/rtm-20160116.927/rtm-autoloads.el
  54. 2
      elpa/rtm-20160116.927/rtm-pkg.el
  55. 697
      elpa/rtm-20160116.927/rtm.el
  56. 49
      elpa/simple-rtm-20160222.734/simple-rtm-autoloads.el
  57. 2
      elpa/simple-rtm-20160222.734/simple-rtm-pkg.el
  58. 1355
      elpa/simple-rtm-20160222.734/simple-rtm.el
  59. 47
      elpa/slack-20160928.2036/slack-autoloads.el
  60. 89
      elpa/slack-20160928.2036/slack-bot-message.el
  61. 327
      elpa/slack-20160928.2036/slack-buffer.el
  62. 236
      elpa/slack-20160928.2036/slack-channel.el
  63. 244
      elpa/slack-20160928.2036/slack-file.el
  64. 192
      elpa/slack-20160928.2036/slack-group.el
  65. 184
      elpa/slack-20160928.2036/slack-im.el
  66. 141
      elpa/slack-20160928.2036/slack-message-editor.el
  67. 182
      elpa/slack-20160928.2036/slack-message-formatter.el
  68. 79
      elpa/slack-20160928.2036/slack-message-notification.el
  69. 155
      elpa/slack-20160928.2036/slack-message-reaction.el
  70. 170
      elpa/slack-20160928.2036/slack-message-sender.el
  71. 295
      elpa/slack-20160928.2036/slack-message.el
  72. 11
      elpa/slack-20160928.2036/slack-pkg.el
  73. 66
      elpa/slack-20160928.2036/slack-reaction.el
  74. 264
      elpa/slack-20160928.2036/slack-reminder.el
  75. 49
      elpa/slack-20160928.2036/slack-reply.el
  76. 80
      elpa/slack-20160928.2036/slack-request.el
  77. 472
      elpa/slack-20160928.2036/slack-room.el
  78. 459
      elpa/slack-20160928.2036/slack-search.el
  79. 202
      elpa/slack-20160928.2036/slack-team.el
  80. 36
      elpa/slack-20160928.2036/slack-user-message.el
  81. 63
      elpa/slack-20160928.2036/slack-user.el
  82. 88
      elpa/slack-20160928.2036/slack-util.el
  83. 510
      elpa/slack-20160928.2036/slack-websocket.el
  84. 191
      elpa/slack-20160928.2036/slack.el
  85. 15
      elpa/websocket-20160720.2051/websocket-autoloads.el
  86. 2
      elpa/websocket-20160720.2051/websocket-pkg.el
  87. 1035
      elpa/websocket-20160720.2051/websocket.el
  88. 5
      init.el

@ -0,0 +1,92 @@
;;; alert-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "alert" "alert.el" (22533 17539 221493 451000))
;;; Generated autoloads from alert.el
(autoload 'alert-add-rule "alert" "\
Programmatically add an alert configuration rule.
Normally, users should custoimze `alert-user-configuration'.
This facility is for module writers and users that need to do
things the Lisp way.
Here is a rule the author currently uses with ERC, so that the
fringe gets colored whenever people chat on BitlBee:
\(alert-add-rule :status \\='(buried visible idle)
:severity \\='(moderate high urgent)
:mode \\='erc-mode
:predicate
#\\='(lambda (info)
(string-match (concat \"\\\\`[^&].*@BitlBee\\\\\\='\")
(erc-format-target-and/or-network)))
:persistent
#\\='(lambda (info)
;; If the buffer is buried, or the user has been
;; idle for `alert-reveal-idle-time' seconds,
;; make this alert persistent. Normally, alerts
;; become persistent after
;; `alert-persist-idle-time' seconds.
(memq (plist-get info :status) \\='(buried idle)))
:style \\='fringe
:continue t)
\(fn &key SEVERITY STATUS MODE CATEGORY TITLE MESSAGE PREDICATE ICON (style alert-default-style) PERSISTENT CONTINUE NEVER-PERSIST APPEND)" nil nil)
(autoload 'alert "alert" "\
Alert the user that something has happened.
MESSAGE is what the user will see. You may also use keyword
arguments to specify additional details. Here is a full example:
\(alert \"This is a message\"
:severity \\='high ;; The default severity is `normal'
:title \"Title\" ;; An optional title
:category \\='example ;; A symbol to identify the message
:mode \\='text-mode ;; Normally determined automatically
:buffer (current-buffer) ;; This is the default
:data nil ;; Unused by alert.el itself
:persistent nil ;; Force the alert to be persistent;
;; it is best not to use this
:never-persist nil ;; Force this alert to never persist
:style \\='fringe) ;; Force a given style to be used;
;; this is only for debugging!
If no :title is given, the buffer-name of :buffer is used. If
:buffer is nil, it is the current buffer at the point of call.
:data is an opaque value which modules can pass through to their
own styles if they wish.
Here are some more typical examples of usage:
;; This is the most basic form usage
(alert \"This is an alert\")
;; You can adjust the severity for more important messages
(alert \"This is an alert\" :severity \\='high)
;; Or decrease it for purely informative ones
(alert \"This is an alert\" :severity \\='trivial)
;; Alerts can have optional titles. Otherwise, the title is the
;; buffer-name of the (current-buffer) where the alert originated.
(alert \"This is an alert\" :title \"My Alert\")
;; Further, alerts can have categories. This allows users to
;; selectively filter on them.
(alert \"This is an alert\" :title \"My Alert\"
:category \\='some-category-or-other)
\(fn MESSAGE &key (severity (quote normal)) TITLE ICON CATEGORY BUFFER MODE DATA STYLE PERSISTENT NEVER-PERSIST)" nil nil)
;;;***
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; End:
;;; alert-autoloads.el ends here

@ -0,0 +1,2 @@
;;; -*- no-byte-compile: t -*-
(define-package "alert" "20160824.821" "Growl-style notification system for Emacs" '((gntp "0.1") (log4e "0.3.0")) :url "https://github.com/jwiegley/alert" :keywords '("notification" "emacs" "message"))

File diff suppressed because it is too large Load Diff

@ -0,0 +1,225 @@
;;; circe-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "circe" "circe.el" (22533 17540 927532 375000))
;;; Generated autoloads from circe.el
(autoload 'circe-version "circe" "\
Display Circe's version.
\(fn)" t nil)
(autoload 'circe "circe" "\
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.
\(fn NETWORK-OR-SERVER &rest SERVER-OPTIONS)" t nil)
;;;***
;;;### (autoloads nil "circe-color-nicks" "circe-color-nicks.el"
;;;;;; (22533 17540 792529 295000))
;;; Generated autoloads from circe-color-nicks.el
(autoload 'enable-circe-color-nicks "circe-color-nicks" "\
Enable the Color Nicks module for Circe.
This module colors all encountered nicks in a cross-server fashion.
\(fn)" t nil)
;;;***
;;;### (autoloads nil "circe-highlight-all-nicks" "circe-highlight-all-nicks.el"
;;;;;; (22533 17541 95536 208000))
;;; Generated autoloads from circe-highlight-all-nicks.el
(autoload 'enable-circe-highlight-all-nicks "circe-highlight-all-nicks" "\
Enable the Highlight Nicks module for Circe.
This module highlights all occurances of nicks in the current
channel in messages of other people.
\(fn)" t nil)
;;;***
;;;### (autoloads nil "circe-lagmon" "circe-lagmon.el" (22533 17540
;;;;;; 882531 348000))
;;; Generated autoloads from circe-lagmon.el
(defvar circe-lagmon-mode nil "\
Non-nil if Circe-Lagmon mode is enabled.
See the `circe-lagmon-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `circe-lagmon-mode'.")
(custom-autoload 'circe-lagmon-mode "circe-lagmon" nil)
(autoload 'circe-lagmon-mode "circe-lagmon" "\
Circe-lagmon-mode monitors the amount of lag on your
connection to each server, and displays the lag time in seconds
in the mode-line.
\(fn &optional ARG)" t nil)
;;;***
;;;### (autoloads nil "circe-new-day-notifier" "circe-new-day-notifier.el"
;;;;;; (22533 17541 242539 562000))
;;; Generated autoloads from circe-new-day-notifier.el
(autoload 'enable-circe-new-day-notifier "circe-new-day-notifier" "\
\(fn)" t nil)
(autoload 'disable-circe-new-day-notifier "circe-new-day-notifier" "\
\(fn)" t nil)
;;;***
;;;### (autoloads nil "lui-autopaste" "lui-autopaste.el" (22533 17541
;;;;;; 5534 154000))
;;; Generated autoloads from lui-autopaste.el
(autoload 'enable-lui-autopaste "lui-autopaste" "\
Enable the lui autopaste feature.
If you enter more than `lui-autopaste-lines' at once, Lui will
ask if you would prefer to use a paste service instead. If you
agree, Lui will paste your input to `lui-autopaste-function' and
replace it with the resulting URL.
\(fn)" t nil)
(autoload 'disable-lui-autopaste "lui-autopaste" "\
Disable the lui autopaste feature.
\(fn)" t nil)
;;;***
;;;### (autoloads nil "lui-irc-colors" "lui-irc-colors.el" (22533
;;;;;; 17541 310541 113000))
;;; Generated autoloads from lui-irc-colors.el
(autoload 'enable-lui-irc-colors "lui-irc-colors" "\
Enable IRC color interpretation for Lui.
\(fn)" t nil)
;;;***
;;;### (autoloads nil "lui-track-bar" "lui-track-bar.el" (22533 17540
;;;;;; 837530 321000))
;;; Generated autoloads from lui-track-bar.el
(autoload 'enable-lui-track-bar "lui-track-bar" "\
Enable a bar in Lui buffers that shows where you stopped reading.
\(fn)" t nil)
;;;***
;;;### (autoloads nil "shorten" "shorten.el" (22533 17541 129536
;;;;;; 984000))
;;; Generated autoloads from shorten.el
(autoload 'shorten-strings "shorten" "\
Takes a list of strings and returns an alist ((STRING
. SHORTENED-STRING) ...). Uses `shorten-split-function' to split
the strings, and `shorten-join-function' to join shortened
components back together into SHORTENED-STRING. See also
`shorten-validate-component-function'.
\(fn STRINGS)" nil nil)
;;;***
;;;### (autoloads nil "tracking" "tracking.el" (22533 17540 713527
;;;;;; 492000))
;;; Generated autoloads from tracking.el
(defvar tracking-mode nil "\
Non-nil if Tracking mode is enabled.
See the `tracking-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `tracking-mode'.")
(custom-autoload 'tracking-mode "tracking" nil)
(autoload 'tracking-mode "tracking" "\
Allow cycling through modified buffers.
This mode in itself does not track buffer modification, but
provides an API for programs to add buffers as modified (using
`tracking-add-buffer').
Once this mode is active, modified buffers are shown in the mode
line. The user can cycle through them using
\\[tracking-next-buffer].
\(fn &optional ARG)" t nil)
(autoload 'tracking-add-buffer "tracking" "\
Add BUFFER as being modified with FACES.
This does check whether BUFFER is currently visible.
If FACES is given, it lists the faces that might be appropriate
for BUFFER in the mode line. The highest-priority face of these
and the current face of the buffer, if any, is used. Priority is
decided according to `tracking-faces-priorities'.
\(fn BUFFER &optional FACES)" nil nil)
(autoload 'tracking-remove-buffer "tracking" "\
Remove BUFFER from being tracked.
\(fn BUFFER)" nil nil)
(autoload 'tracking-next-buffer "tracking" "\
Switch to the next active buffer.
\(fn)" t nil)
(autoload 'tracking-previous-buffer "tracking" "\
Switch to the last active buffer.
\(fn)" t nil)
;;;***
;;;### (autoloads nil nil ("circe-chanop.el" "circe-compat.el" "circe-pkg.el"
;;;;;; "irc.el" "lcs.el" "lui-format.el" "lui-logging.el" "lui.el"
;;;;;; "make-tls-process.el") (22533 17541 344541 889000))
;;;***
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; End:
;;; circe-autoloads.el ends here

@ -0,0 +1,97 @@
;;; circe-chanop.el --- Provide common channel operator commands
;; Copyright (C) 2006, 2015 Jorgen Schaefer
;; Author: Jorgen Schaefer <forcer@forcix.cx>
;; 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, write to the Free Software
;; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
;; 02110-1301 USA
;;; Commentary:
;; This Circe module provides some often-used chanop commands. I was
;; very reluctant to add this. None of these commands will make it in
;; the core, or even be provided by default. You should have to go to
;; great lengths to use them.
;; Always remember the Tao of IRC:
;;
;; IGNORE is the weapon of an IRC knight. Not as clumsy or as
;; random as a kickban.
;;; Code:
(require 'circe)
(defun circe-command-MODE (mode)
"Set MODE in the current channel."
(interactive "sMode change: ")
(cond
((not (string-match "^[+-]" mode))
(irc-send-raw (circe-server-process)
(format "MODE %s" mode)))
((eq major-mode 'circe-channel-mode)
(irc-send-raw (circe-server-process)
(format "MODE %s %s" circe-chat-target mode)))
(t
(circe-display-server-message "Not in a channel buffer."))))
(defun circe-command-BANS (&optional ignored)
"Show channel bans"
(if (not circe-chat-target)
(circe-display-server-message "No target for current buffer")
(irc-send-raw (circe-server-process)
(format "MODE %s +b" circe-chat-target))))
(defun circe-command-KICK (nick &optional reason)
"Kick WHO from the current channel with optional REASON."
(interactive "sKick who: \nsWhy: ")
(if (not (eq major-mode 'circe-channel-mode))
(circe-display-server-message "Not in a channel buffer.")
(when (not reason)
(if (string-match "^\\([^ ]*\\) +\\(.+\\)" nick)
(setq reason (match-string 2 nick)
nick (match-string 1 nick))
(setq reason "-")))
(irc-send-raw (circe-server-process)
(format "KICK %s %s :%s"
circe-chat-target nick reason))))
(defun circe-command-GETOP (&optional ignored)
"Ask chanserv for op on the current channel."
(interactive)
(if (not (eq major-mode 'circe-channel-mode))
(circe-display-server-message "Not in a channel buffer.")
(irc-send-PRIVMSG (circe-server-process)
"chanserv"
(format "op %s" circe-chat-target))))
(defun circe-command-DROPOP (&optional ignored)
"Lose op mode on the current channel."
(interactive)
(if (not (eq major-mode 'circe-channel-mode))
(circe-display-server-message "Not in a channel buffer.")
(irc-send-raw (circe-server-process)
(format "MODE %s -o %s"
circe-chat-target
(circe-nick)))))
;; For KICKBAN (requested by Riastradh), we'd need a callback on a
;; USERHOST command.
(provide 'circe-chanop)
;;; circe-chanop.el ends here

@ -0,0 +1,345 @@
;;; circe-color-nicks.el --- Color nicks in the channel
;; Copyright (C) 2012 Taylan Ulrich Bayırlı/Kammer
;; Author: Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
;; 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, write to the Free Software
;; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
;; 02110-1301 USA
;;; Commentary:
;; This Circe module adds the ability to assign a color to each
;; nick in a channel.
;; Some ideas/code copied from rcirc-colors.el.
;; To use it, put the following into your .emacs:
;; (require 'circe-color-nicks)
;; (enable-circe-color-nicks)
;;; Code:
(require 'circe)
(require 'color)
(require 'cl-lib)
;;;###autoload
(defun enable-circe-color-nicks ()
"Enable the Color Nicks module for Circe.
This module colors all encountered nicks in a cross-server fashion."
(interactive)
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (eq major-mode 'circe-channel-mode)
(add-circe-color-nicks))))
(add-hook 'circe-channel-mode-hook
'add-circe-color-nicks))
(defun disable-circe-color-nicks ()
"Disable the Color Nicks module for Circe.
See `enable-circe-color-nicks'."
(interactive)
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (eq major-mode 'circe-channel-mode)
(remove-circe-color-nicks))))
(remove-hook 'circe-channel-mode-hook
'add-circe-color-nicks))
(defun add-circe-color-nicks ()
"Add `circe-color-nicks' to `lui-pre-output-hook'."
(add-hook 'lui-pre-output-hook 'circe-color-nicks))
(defun remove-circe-color-nicks ()
"Remove `circe-color-nicks' from `lui-pre-output-hook'."
(remove-hook 'lui-pre-output-hook 'circe-color-nicks))
(defgroup circe-color-nicks nil
"Nicks colorization for Circe"
:prefix "circe-color-nicks-"
:group 'circe)
(defcustom circe-color-nicks-min-contrast-ratio 7
"Minimum contrast ratio from background for generated colors;
recommended is 7:1, or at least 4.5:1 (7 stands for 7:1 here).
Lower value allows higher color spread, but could lead to less
readability."
:group 'circe-color-nicks)
(defcustom circe-color-nicks-min-difference 17
"Minimum difference from each other for generated colors."
:group 'circe-color-nicks)
(defcustom circe-color-nicks-min-fg-difference 17
"Minimum difference from foreground for generated colors."
:group 'circe-color-nicks)
(defcustom circe-color-nicks-min-my-message-difference 0
"Minimum difference from own nick color for generated colors."
:group 'circe-color-nicks)
(defcustom circe-color-nicks-everywhere nil
"Whether nicks should be colored in message bodies too."
:type 'boolean
:group 'circe-color-nicks)
(defcustom circe-color-nicks-message-blacklist nil
"Blacklist for nicks that shall never be highlighted inside
images."
:type '(repeat string)
:group 'circe-color-nicks)
(defcustom circe-color-nicks-pool-type 'adaptive
"Type of the color nick pool.
Must be one of the following:
'adaptive: Generate colors based on the current theme.
List of strings: Pick colors from the specified list of hex codes
or color names (see `color-name-rgb-alist')."
:type '(choice (const :tag "Adaptive" adaptive)
(repeat string))
:group 'circe-color-nicks)
;;; See http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G18
(defsubst circe-w3-contrast-c-to-l (c)
(if (<= c 0.03928)
(/ c 12.92)
(expt (/ (+ c 0.055) 1.055) 2.4)))
(defsubst circe-w3-contrast-relative-luminance (rgb)
(apply #'+
(cl-mapcar (lambda (color coefficient)
(* coefficient
(circe-w3-contrast-c-to-l color)))
rgb
'(0.2126 0.7152 0.0722))))
(defsubst circe-w3-contrast-contrast-ratio (color1 color2)
(let ((l1 (+ 0.05 (circe-w3-contrast-relative-luminance color1)))
(l2 (+ 0.05 (circe-w3-contrast-relative-luminance color2))))
(if (> l1 l2)
(/ l1 l2)
(/ l2 l1))))
(defun circe-color-alist ()
"Return list of colors (name rgb lab) where rgb is 0 to 1."
(let ((alist (if (display-graphic-p)
color-name-rgb-alist
(mapcar (lambda (c)
(cons (car c) (cddr c)))
(tty-color-alist))))
(valmax (float (car (color-values "#ffffff")))))
(mapcar (lambda (c)
(let* ((name (car c))
(rgb (mapcar (lambda (v)
(/ v valmax))
(cdr c)))
(lab (apply #'color-srgb-to-lab rgb)))
(list name rgb lab)))
alist)))
(defun circe-color-canonicalize-format (color)
"Turns COLOR into (name rgb lab) format. Avoid calling this in
a loop, it's very slow on a tty!"
(let* ((name color)
(rgb (circe-color-name-to-rgb color))
(lab (apply #'color-srgb-to-lab rgb)))
(list name rgb lab)))
(defun circe-color-contrast-ratio (color1 color2)
"Gives the contrast ratio between two colors."
(circe-w3-contrast-contrast-ratio (nth 1 color1) (nth 1 color2)))
(defun circe-color-diff (color1 color2)
"Gives the difference between two colors per CIEDE2000."
(color-cie-de2000 (nth 2 color1) (nth 2 color2)))
(defun circe-color-name-to-rgb (color)
"Like `color-name-to-rgb' but also handles \"unspecified-bg\"
and \"unspecified-fg\"."
(cond ((equal color "unspecified-bg") '(0 0 0))
((equal color "unspecified-fg") '(1 1 1))
(t (color-name-to-rgb color))))
(defun circe-nick-color-appropriate-p (color bg fg my-msg)
"Tells whether COLOR is appropriate for being a nick color.
BG, FG, and MY-MSG are the background, foreground, and my-message
colors; these are expected as parameters instead of computed here
because computing them repeatedly is a heavy operation."
(and (>= (circe-color-contrast-ratio color bg)
circe-color-nicks-min-contrast-ratio)
(>= (circe-color-diff color fg)
circe-color-nicks-min-fg-difference)
(>= (circe-color-diff color my-msg)
circe-color-nicks-min-my-message-difference)))
(defun circe-nick-colors-delete-similar (colors)
"Return list COLORS with pairs of colors filtered out that are
too similar per `circe-color-nicks-min-difference'. COLORS may
be mutated."
(cl-mapl (lambda (rest)
(let ((color (car rest)))
(setcdr rest (cl-delete-if
(lambda (c)
(< (circe-color-diff color c)
circe-color-nicks-min-difference))
(cdr rest)))))
colors)
colors)
(defun circe-nick-color-generate-pool ()
"Return a list of appropriate nick colors."
(if (consp circe-color-nicks-pool-type)
circe-color-nicks-pool-type
(let ((bg (circe-color-canonicalize-format (face-background 'default)))
(fg (circe-color-canonicalize-format (face-foreground 'default)))
(my-msg (circe-color-canonicalize-format
(face-attribute
'circe-my-message-face :foreground nil 'default))))
(mapcar #'car (circe-nick-colors-delete-similar
(cl-remove-if-not
(lambda (c)
(circe-nick-color-appropriate-p c bg fg my-msg))
(circe-color-alist)))))))
(defun circe-nick-color-pool-test ()
"Display all appropriate nick colors in a temp buffer."
(interactive)
(switch-to-buffer (get-buffer-create "*Circe color test*"))
(erase-buffer)
(let ((pool (circe-nick-color-generate-pool)))
(while pool
(let ((pt (point)))
(insert "The quick brown fox jumped over the lazy dog.\n")
(put-text-property pt (point) 'face `(:foreground ,(pop pool)))))))
(defvar circe-nick-color-pool nil
"Pool of yet unused nick colors.")
(defvar circe-nick-color-mapping (make-hash-table :test 'equal)
"Hash-table from nicks to colors.")
(defun circe-nick-color-nick-list ()
"Return list of all nicks that have a color assigned to them.
Own and blacklisted nicks are excluded."
(let ((our-nick (circe-nick))
(channel-nicks (circe-channel-nicks))
nicks)
(maphash
(lambda (nick color)
(when (and (member nick channel-nicks)
(not (string= our-nick nick))
(not (member nick circe-color-nicks-message-blacklist)))
(push nick nicks)))
circe-nick-color-mapping)
nicks))
(defvar circe-nick-color-timestamps (make-hash-table :test 'equal)
"Hash-table from colors to the timestamp of their last use.")
(defun circe-nick-color-for-nick (nick)
"Return the color for NICK. Assigns a color to NICK if one
wasn't assigned already."
(let ((color (gethash nick circe-nick-color-mapping)))
(when (not color)
;; NOTE use this as entry point for taking NICK into account for
;; picking the new color
(setq color (circe-nick-color-pick))
(puthash nick color circe-nick-color-mapping))
(puthash color (float-time) circe-nick-color-timestamps)
color))
(defun circe-nick-color-pick ()
"Picks either a color from the pool of unused colors, or the
color that was used least recently (i.e. nicks that have it
assigned have been least recently active)."
(if (zerop (hash-table-count circe-nick-color-mapping))
(setq circe-nick-color-pool (circe-nick-color-generate-pool)))
(or (pop circe-nick-color-pool)
(circe-nick-color-pick-least-recent)))
(defun circe-nick-color-pick-least-recent ()
"Pick the color that was used least recently.
See `circe-nick-color-pick', which is where this is used."
(let ((least-recent-color nil)
(oldest-time (float-time)))
(maphash
(lambda (color time)
(if (< time oldest-time)
(progn
(setq least-recent-color color)
(setq oldest-time time))))
circe-nick-color-timestamps)
(if least-recent-color
least-recent-color
;; Someone must have messed with `circe-nick-color-mapping', recover by
;; re-filling the pool.
(setq circe-nick-color-pool (circe-nick-color-generate-pool))
(pop circe-nick-color-pool))))
(defun circe-color-nicks ()
"Color nicks on this lui output line."
(when (eq major-mode 'circe-channel-mode)
(let ((nickstart (text-property-any (point-min) (point-max)
'lui-format-argument 'nick)))
(when nickstart
(goto-char nickstart)
(let ((nickend (next-single-property-change nickstart
'lui-format-argument))
(nick (plist-get (plist-get (text-properties-at nickstart)
'lui-keywords)
:nick)))
(when (not (circe-server-my-nick-p nick))
(let ((color (circe-nick-color-for-nick nick)))
(add-face-text-property nickstart nickend
`(:foreground ,color)))))))
(when circe-color-nicks-everywhere
(let ((body (text-property-any (point-min) (point-max)
'lui-format-argument 'body)))
(when body
(with-syntax-table circe-nick-syntax-table
(goto-char body)
(let* ((nicks (circe-nick-color-nick-list))
(regex (regexp-opt nicks 'words)))
(let (case-fold-search)
(while (re-search-forward regex nil t)
(let* ((nick (match-string-no-properties 0))
(color (circe-nick-color-for-nick nick)))
(add-face-text-property (match-beginning 0) (match-end 0)
`(:foreground ,color))))))))))))
(defun circe-nick-color-reset ()
"Reset the nick color mapping (and some internal data).
This is useful if you switched between frames supporting
different color ranges and would like nicks to get new colors
appropriate to the new color range."
(interactive)
(setq circe-nick-color-pool (circe-nick-color-generate-pool))
(setq circe-nick-color-mapping (make-hash-table :test 'equal))
(setq circe-nick-color-timestamps (make-hash-table :test 'equal)))
(provide 'circe-color-nicks)
;;; circe-color-nicks.el ends here

@ -0,0 +1,53 @@
;;; circe-compat.el --- Compatibility definitions
;; Copyright (C) 2015 Jorgen Schaefer <contact@jorgenschaefer.de>
;; Author: Jorgen Schaefer <contact@jorgenschaefer.de>
;; 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:
;; Define functions and variables as needed by Circe to remain
;; compatible with older Emacsen.
;;; Code:
(when (not (fboundp 'string-trim))
(defun string-trim (string)
"Remove leading and trailing whitespace from STRING."
(if (string-match "\\` *\\(.*[^[:space:]]\\) *\\'" string)
(match-string 1 string)
string)))
(when (not (fboundp 'add-face-text-property))
(defun add-face-text-property (start end face &optional append object)
(while (/= start end)
(let* ((next (next-single-property-change start 'face object end))
(prev (get-text-property start 'face object))
(value (if (listp prev) prev (list prev))))
(put-text-property start next 'face
(if append
(append value (list face))
(append (list face) value))
object)
(setq start next)))))
(when (not (boundp 'mode-line-misc-info))
(defvar mode-line-misc-info nil
"Misc info in the mode line.")
(add-to-list 'mode-line-format 'mode-line-misc-info t))
(provide 'circe-compat)
;;; circe-compat.el ends here

@ -0,0 +1,100 @@
;;; circe-highlight-all-nicks.el --- Highlight all nicks in the current channel
;; Copyright (C) 2005 Jorgen Schaefer
;; Author: Jorgen Schaefer <forcer@forcix.cx>
;; 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, write to the Free Software
;; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
;; 02110-1301 USA
;;; Commentary:
;; This Circe module adds the ability to highlight every occurance of
;; a nick in the current channel in a message by other people.
;; To use it, put the following into your .emacs:
;; (require 'circe-highlight-all-nicks)
;; (enable-circe-highlight-all-nicks)
;;; Code:
(require 'circe)
(defface circe-highlight-all-nicks-face
'((t (:foreground "green")))
"The face used for nicks from the current channel.
See `enable-circe-highlight-all-nicks'."
:group 'circe)
;;;###autoload
(defun enable-circe-highlight-all-nicks ()
"Enable the Highlight Nicks module for Circe.
This module highlights all occurances of nicks in the current
channel in messages of other people."
(interactive)
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (eq major-mode 'circe-channel-mode)
(add-circe-highlight-all-nicks))))
(add-hook 'circe-channel-mode-hook
'add-circe-highlight-all-nicks))
(defun disable-circe-highlight-all-nicks ()
"Disable the Highlight Nicks module for Circe.
See `enable-circe-highlight-all-nicks'."
(interactive)
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (eq major-mode 'circe-channel-mode)
(remove-circe-highlight-all-nicks))))
(remove-hook 'circe-channel-mode-hook
'add-circe-highlight-all-nicks))
(defun add-circe-highlight-all-nicks ()
"Add `circe-highlight-all-nicks' to `lui-pre-output-hook'."
(add-hook 'lui-pre-output-hook 'circe-highlight-all-nicks
nil t))
(defun remove-circe-highlight-all-nicks ()
"Remove `circe-highlight-all-nicks' from `lui-pre-output-hook'."
(remove-hook 'lui-pre-output-hook 'circe-highlight-all-nicks
t))
(defun circe-highlight-all-nicks ()
"Highlight all occurances of nicks of the current channel in the message."
(when (eq major-mode 'circe-channel-mode)
(let ((body (text-property-any (point-min) (point-max)
'lui-format-argument 'body))
(nicks '())
(regex nil))
(when body
(let ((channel-nicks (circe-channel-nicks)))
(when channel-nicks
(mapc (lambda (nick)
(when (not (circe-server-my-nick-p nick))
(setq nicks (cons nick nicks))))
channel-nicks)))
(setq regex (regexp-opt nicks 'words))
(goto-char body)
(while (re-search-forward regex nil t)
(add-text-properties (match-beginning 0)
(match-end 0)
'(face circe-highlight-all-nicks-face)))))))
(provide 'circe-highlight-all-nicks)
;;; circe-highlight-all-nicks.el ends here

@ -0,0 +1,243 @@
;;; circe-lagmon.el --- Lag Monitor for Circe
;; Copyright (C) 2011-2012 Jorgen Schaefer
;; Author: John J Foerch <jjfoerch@earthlink.net>,
;; Jorgen Schaefer
;; 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, write to the Free Software
;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
;; 02110-1301, USA.
;;; Commentary:
;;;
;;; Circe-lagmon-mode monitors the amount of lag on your connection to
;;; each server, and displays the lag time in seconds in the mode-line.
;;; It works by managing two timers. Timer1 sends CTCP LAGMON to yourself
;;; on each server every 60 seconds. Each time around, timer1 starts
;;; timer2 to monitor for timeouts of these messages. Timer2 cancels
;;; itself when all of the pings in the round have been answered.
;;;
;;; Code:
(require 'circe)
;;; User variables
(defgroup circe-lagmon nil
"Lag Monitor for Circe"
:prefix "circe-lagmon-"
:group 'circe)
(defcustom circe-lagmon-timer-tick 5
"How often to check for lag.
Increase this to improve performance at the cost of accuracy."
:type 'number
:group 'circe-lagmon)
(defcustom circe-lagmon-check-interval 60
"Interval in seconds at which to send the CTCP message."
:type 'number
:group 'circe-lagmon)
(defcustom circe-lagmon-reconnect-interval 120
"Seconds after which to automatically reconnect upon a timeout
of a lag monitor message. A value of nil disables the feature."
:type '(choice (const :tag "Disable auto-reconnect" nil)
number)
:group 'circe-lagmon)
(defcustom circe-lagmon-mode-line-format-string "lag:%.1f "
"Format string for displaying the lag in the mode-line."
:type 'string
:group 'circe-lagmon)
(defcustom circe-lagmon-mode-line-unknown-lag-string "lag:? "
"Indicator string for displaying unknown lag in the mode-line."
:type 'string
:group 'circe-lagmon)
(defvar circe-lagmon-disabled nil
"A boolean value if lagmon should be disabled on this network.
Don't set this by hand, use `circe-network-options'.")
(make-variable-buffer-local 'circe-lagmon-disabled)
;;; Internal variables
;;;
(defvar circe-lagmon-timer nil)
(defvar circe-lagmon-server-lag nil)
(make-variable-buffer-local 'circe-lagmon-server-lag)
(defvar circe-lagmon-last-send-time nil)
(make-variable-buffer-local 'circe-lagmon-last-send-time)
(defvar circe-lagmon-last-receive-time nil)
(make-variable-buffer-local 'circe-lagmon-last-receive-time)
(defun circe-lagmon-timer-tick ()
"Function run periodically to check lag.
This will call `circe-lagmon-server-check' in every active server
buffer. You can call it yourself if you like to force an update,
there is no harm in running it too often, but it really should be
run sufficiently often with the timer."
(dolist (buffer (circe-server-buffers))
(with-current-buffer buffer
(when (and (eq major-mode 'circe-server-mode)
circe-server-process
(eq (irc-connection-state circe-server-process)
'registered)
(not circe-lagmon-disabled))
(circe-lagmon-server-check)))))
(defun circe-lagmon-server-check ()
"Check the current server for lag.
This will reconnect if we haven't heard back for too long, or
send a request if it's time for that. See
`circe-lagmon-reconnect-interval' and
`circe-lagmon-check-interval' to configure the behavior.."
(let ((now (float-time)))
(cond
;; No answer so far...
((and circe-lagmon-last-send-time
(not circe-lagmon-last-receive-time))
;; Count up until the answer comes.
(let ((lag (/ (- now circe-lagmon-last-send-time) 2)))
(when (or (not circe-lagmon-server-lag)
(> lag circe-lagmon-server-lag))
(setq circe-lagmon-server-lag lag)
(circe-lagmon-force-mode-line-update)))
;; Check for timeout.
(when (and circe-lagmon-reconnect-interval
(> now
(+ circe-lagmon-last-send-time
circe-lagmon-reconnect-interval)))
(setq circe-lagmon-last-send-time nil
circe-lagmon-last-receive-time nil)
(circe-reconnect)))
;; Nothing sent so far, or last send was too long ago.
((or (not circe-lagmon-last-send-time)
(> now
(+ circe-lagmon-last-send-time
circe-lagmon-check-interval)))
(irc-send-raw (circe-server-process)
(format "PRIVMSG %s :\C-aLAGMON %s\C-a"
(circe-nick) now)
:nowait)
(setq circe-lagmon-last-send-time now
circe-lagmon-last-receive-time nil))
)))
(defun circe-lagmon-force-mode-line-update ()
"Call force-mode-line-update on a circe server buffer and all
of its chat buffers."
(force-mode-line-update)
(dolist (b (circe-server-chat-buffers))
(with-current-buffer b
(force-mode-line-update))))
(defun circe-lagmon-format-mode-line-entry ()
"Format the mode-line entry for displaying the lag."
(let ((buf (cond
((eq major-mode 'circe-server-mode)
(current-buffer))
(circe-server-buffer
circe-server-buffer)
(t
nil))))
(when buf
(with-current-buffer buf
(cond
(circe-lagmon-disabled
nil)
(circe-lagmon-server-lag
(format circe-lagmon-mode-line-format-string
circe-lagmon-server-lag))
(t
circe-lagmon-mode-line-unknown-lag-string))))))
(defun circe-lagmon-init ()
"Initialize the values of the lag monitor for one server, and
start the lag monitor if it has not been started."
(setq circe-lagmon-server-lag nil
circe-lagmon-last-send-time nil
circe-lagmon-last-receive-time nil)
(circe-lagmon-force-mode-line-update)
(unless circe-lagmon-timer
(setq circe-lagmon-timer
(run-at-time nil circe-lagmon-timer-tick
'circe-lagmon-timer-tick))))
(defun circe-lagmon--rpl-welcome-handler (conn &rest ignored)
(with-current-buffer (irc-connection-get conn :server-buffer)
(circe-lagmon-init)))
(defun circe-lagmon--ctcp-lagmon-handler (conn event sender target argument)
(when (irc-current-nick-p conn (irc-userstring-nick sender))
(with-current-buffer (irc-connection-get conn :server-buffer)
(let* ((now (float-time))
(lag (/ (- now (string-to-number argument))
2)))
(setq circe-lagmon-server-lag lag
circe-lagmon-last-receive-time now)
(circe-lagmon-force-mode-line-update)))))
(defun circe-lagmon--nick-handler (conn event sender new-nick)
(when (irc-current-nick-p conn (irc-userstring-nick sender))
(with-current-buffer (irc-connection-get conn :server-buffer)
(setq circe-lagmon-last-send-time nil))))
;;;###autoload
(define-minor-mode circe-lagmon-mode
"Circe-lagmon-mode monitors the amount of lag on your
connection to each server, and displays the lag time in seconds
in the mode-line."
:global t
(let ((mode-line-entry '(:eval (circe-lagmon-format-mode-line-entry))))
(remove-hook 'mode-line-modes mode-line-entry)
(let ((table (circe-irc-handler-table)))
(irc-handler-remove table "001" 'circe-lagmon--rpl-welcome-handler)
(irc-handler-remove table "irc.ctcp.LAGMON"
'circe-lagmon--ctcp-lagmon-handler)
(irc-handler-remove table "NICK" 'circe-lagmon--nick-handler))
(circe-set-display-handler "irc.ctcp.LAGMON" nil)
(when circe-lagmon-timer
(cancel-timer circe-lagmon-timer)
(setq circe-lagmon-timer nil))
(when circe-lagmon-mode
(add-hook 'mode-line-modes mode-line-entry)
(let ((table (circe-irc-handler-table)))
(irc-handler-add table "001" 'circe-lagmon--rpl-welcome-handler)
(irc-handler-add table "irc.ctcp.LAGMON"
'circe-lagmon--ctcp-lagmon-handler)
(irc-handler-add table "NICK" 'circe-lagmon--nick-handler))
(circe-set-display-handler "irc.ctcp.LAGMON" 'circe-display-ignore)
(dolist (buffer (circe-server-buffers))
(with-current-buffer buffer
(setq circe-lagmon-server-lag nil)
(when (and circe-server-process
(eq (irc-connection-state circe-server-process)
'registered))
(circe-lagmon-init)))))))
(provide 'circe-lagmon)
;;; circe-lagmon.el ends here

@ -0,0 +1,86 @@
;;; circe-new-day-notifier.el --- Send a message every midnight to all
;;; channels
;; Copyright (C) 2015 Pásztor János
;; Author: Pásztor János <model87@freemail.hu>
;; 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 2
;; of the License, or (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, write to the Free Software
;; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
;; 02110-1301 USA
;;; Commentary:
;; This Circe module adds the ability to send a notification to all
;; channels every midnight
;; Some ideas/code copied from circe-lagmon.el and
;; circe-color-nicks.el
;; To use it, put the following into your .emacs:
;; (require 'circe-new-day-notifier)
;; (enable-circe-new-day-notifier)
;;; Code:
(require 'circe)
(defgroup circe-new-day-notifier nil
"Midnight notification to Circe"
:prefix "circe-new-day-notifier-"
:group 'circe)
(defcustom circe-new-day-notifier-format-message "*** Day changed to {day}"
"The format string which will be printed to the channels. It
should contain {day} to print the date. See `circe-display' for
further documentation"
:type 'string
:group 'circe-new-day-notifier)
(defcustom circe-new-day-notifier-date-format "%Y-%m-%d, %A"
"The date format, which will be used at
circe-new-day-notifier-format-message. See `format-time-string' for
documentation"
:type 'string
:group 'circe-new-day-notifier)
(defvar circe-new-day-notifier-timer nil)
;;;###autoload
(defun enable-circe-new-day-notifier ()
(interactive)
(unless circe-new-day-notifier-timer
(setq circe-new-day-notifier-timer
(run-at-time "24:00:00" (* 24 60 60) 'circe-new-day-notification))))
;;;###autoload
(defun disable-circe-new-day-notifier ()
(interactive)
(when circe-new-day-notifier-timer
(cancel-timer circe-new-day-notifier-timer)
(setq circe-new-day-notifier-timer nil)))
(defun circe-new-day-notification ()
"This function prints the new day notification to each query and chat buffer"
(dolist (buf (buffer-list))
(with-current-buffer buf
(when (derived-mode-p 'circe-chat-mode)
(circe-display 'circe-new-day-notifier-format-message
:day (format-time-string circe-new-day-notifier-date-format))))))
(provide 'circe-new-day-notifier)
;;; circe-new-day-notifier.el ends here

@ -0,0 +1,6 @@
(define-package "circe" "20160608.1315" "Client for IRC in Emacs"
'((cl-lib "0.5"))
:url "https://github.com/jorgenschaefer/circe")
;; Local Variables:
;; no-byte-compile: t
;; End:

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

@ -0,0 +1,202 @@
;;; lcs.el --- find out the longest common sequence
;; Copyright (c) 2002-2003 by Alex Shinn, All rights reserved.
;; Copyright (c) 2002-2003 by Shiro Kawai, All rights reserved.
;; Copyright (c) 2006, 2012 by Jorgen Schaefer, All rights reserved.
;; Authors: Alex Shinn, Shiro Kawai
;; Maintainer: Jorgen Schaefer <forcer@forcix.cx>
;; URL: https://github.com/jorgenschaefer/circe/wiki/lcs
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;; 2. Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; 3. Neither the name of the authors nor the names of its contributors
;; may be used to endorse or promote products derived from this
;; software without specific prior written permission.
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;; Commentary:
;; lcs.el is a library for other Emacs Lisp programs not useful by
;; itself.
;; This library provides functions to find the Longest Common Sequence
;; (LCS) of two sequences. This is used to create a unified diff of to
;; two lists. See `lcs-unified-diff' for a useful function to be
;; called.
;; The code is more or less a literal translation of (part of)
;; Gauche's util/lcs.scm module to Emacs Lisp.
;;; Code:
(put 'lcs-for 'lisp-indent-function 4)
(defmacro lcs-for (var from to step &rest body)
"A simple FOR loop macro.
Count VAR from FROM to TO by stepsize STEP. Evaluate BODY in each
iteration."
(let ((sto (make-symbol "to"))
(sstep (make-symbol "step")))
`(let ((,var ,from)
(,sto ,to)
(,sstep ,step))
(while (<= ,var ,sto)
(progn
,@body)
(setq ,var (+ ,var ,sstep))))))
(defun lcs-split-at (lis pos)
"Return a cons cell of the first POS elements of LIS and the rest."
(let ((head nil))
(while (> pos 0)
(setq head (cons (car lis)
head)
pos (- pos 1)
lis (cdr lis)))
(cons (reverse head)
lis)))
(defun lcs-finish (M+N V_l vl V_r vr)
"Finalize the LCS algorithm.
Should be used only by `lcs-with-positions'."
(let ((maxl 0)
(r '()))
(lcs-for i (- M+N) M+N 1
(when (> (funcall vl i)
maxl)
(setq maxl (funcall vl i)
r (funcall vr i))))
(list maxl (reverse r))))
(defun lcs-with-positions (a-ls b-ls &optional equalp)
"Return the longest common subsequence (LCS) of A-LS and B-LS.
EQUALP can be any procedure which returns non-nil when two
elements should be considered equal."
(let* ((A (vconcat a-ls))
(B (vconcat b-ls))
(N (length A))
(M (length B))
(M+N (+ M N))
(V_d (make-vector (+ 1 (* 2 M+N))
0))
(V_r (make-vector (+ 1 (* 2 M+N))
nil))
(V_l (make-vector (+ 1 (* 2 M+N))
0))
(vd (lambda (i &optional x)
(if x
(aset V_d (+ i M+N) x)
(aref V_d (+ i M+N)))))
(vr (lambda (i &optional x)
(if x
(aset V_r (+ i M+N) x)
(aref V_r (+ i M+N)))))
(vl (lambda (i &optional x)
(if x
(aset V_l (+ i M+N) x)
(aref V_l (+ i M+N))))))
(when (not equalp)
(setq equalp 'equal))
(catch 'return
(if (= M+N 0)
(throw 'return '(0 ()))