cgit.sxemacs.org Git - riece/blob - lisp/riece-ruby.el

   1 ;;; riece-ruby.el --- interact with Ruby interpreter
   2 ;; Copyright (C) 1998-2005 Daiki Ueno
   3
   4 ;; Author: Daiki Ueno <ueno@unixuser.org>
   5 ;; Created: 1998-09-28
   6 ;; Keywords: IRC, riece
   7
   8 ;; This file is part of Riece.
   9
  10 ;; This program is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; This program is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26
  27 ;; riece-ruby.el is a library to interact with the Ruby interpreter.
  28 ;; It supports concurrent execution of Ruby programs in a single
  29 ;; session.  For example:
  30 ;;
  31 ;; (riece-ruby-execute "sleep 30"); returns immediately
  32 ;; => "rubyserv0"
  33 ;;
  34 ;; (riece-ruby-execute "1 + 1")
  35 ;; => "rubyserv1"
  36 ;;
  37 ;; (riece-ruby-execute "\"")
  38 ;; => "rubyserv2"
  39 ;;
  40 ;; (riece-ruby-inspect "rubyserv0")
  41 ;; => ((OK nil) nil "running")
  42 ;;
  43 ;; (riece-ruby-inspect "rubyserv1")
  44 ;; => ((OK nil) "2" "finished")
  45 ;;
  46 ;; (riece-ruby-inspect "rubyserv2")
  47 ;; => ((OK nil) "(eval):1: unterminated string meets end of file" "exited")
  48
  49 ;;; Code:
  50
  51 (defgroup riece-ruby nil
  52   "Interact with the Ruby interpreter."
  53   :group 'riece)
  54
  55 (defcustom riece-ruby-command "ruby"
  56   "Command name for Ruby interpreter."
  57   :type 'string
  58   :group 'riece-ruby)
  59
  60 (defvar riece-ruby-server-program "server.rb"
  61   "The server program file.  If the filename is not absolute, it is
  62 assumed that the file is in the same directory of this file.")
  63
  64 (defvar riece-ruby-process nil
  65   "Process object of the Ruby interpreter.")
  66
  67 (defvar riece-ruby-lock nil
  68   "Lock for waiting server response.
  69 Local to the process buffer.")
  70 (defvar riece-ruby-response nil
  71   "The server response.
  72 Local to the process buffer.")
  73 (defvar riece-ruby-data nil
  74   "Data from server.
  75 Local to the process buffer.")
  76 (defvar riece-ruby-escaped-data nil
  77   "Escaped data from server.  This variable is cleared every time
  78 server response arrives.
  79 Local to the process buffer.")
  80 (defvar riece-ruby-status-alist nil
  81   "Status from server.
  82 Local to the process buffer.")
  83
  84 (defvar riece-ruby-output-handler-alist nil
  85   "An alist mapping from program name to output handler.
  86 Output handlers are called every time \"# output\" line arrives.
  87 Use `riece-ruby-set-output-handler' to set this variable.")
  88 (defvar riece-ruby-exit-handler-alist nil
  89   "An alist mapping from program name to exit handler.
  90 Exit handlers are called once when \"# exit\" line arrives.
  91 Use `riece-ruby-set-exit-handler' to set this variable.")
  92 (defvar riece-ruby-property-alist nil
  93   "An alist mapping from program name to the property list.
  94 Use `riece-ruby-set-property' to set this variable.")
  95
  96 (defvar riece-ruby-enabled nil)
  97
  98 (defconst riece-ruby-description
  99   "Evaluate an input string as Ruby program.")
 100
 101 (defun riece-ruby-substitute-variables (program alist)
 102   (setq program (copy-sequence program))
 103   (while alist
 104     (let ((pointer program))
 105       (while pointer
 106         (setq pointer (memq (car (car alist)) program))
 107         (if pointer
 108             (setcar pointer (cdr (car alist))))))
 109     (setq alist (cdr alist)))
 110   (apply #'concat program))
 111
 112 (defun riece-ruby-escape-data (data)
 113   (let ((index 0))
 114     (while (string-match "[%\r\n]+" data index)
 115       (setq data (replace-match
 116                   (mapconcat (lambda (c) (format "%%%02X" c))
 117                              (match-string 0 data) "")
 118                   nil nil data)
 119             index (+ (match-end 0)
 120                      (* (- (match-end 0) (match-beginning 0)) 2))))
 121     data))
 122
 123 (defun riece-ruby-unescape-data (data)
 124   (let ((index 0))
 125     (while (string-match "%\\([0-9A-F][0-9A-F]\\)" data index)
 126       (setq data (replace-match
 127                   (read (concat "\"\\x" (match-string 1 data) "\""))
 128                   nil nil data)
 129             index (- (match-end 0) 2)))
 130     data))
 131
 132 (defun riece-ruby-reset-process-buffer ()
 133   (save-excursion
 134     (set-buffer (process-buffer riece-ruby-process))
 135     (buffer-disable-undo)
 136     (make-local-variable 'riece-ruby-response)
 137     (setq riece-ruby-response nil)
 138     (make-local-variable 'riece-ruby-data)
 139     (setq riece-ruby-data nil)
 140     (make-local-variable 'riece-ruby-escaped-data)
 141     (setq riece-ruby-escaped-data nil)
 142     (make-local-variable 'riece-ruby-status-alist)
 143     (setq riece-ruby-status-alist nil)))
 144
 145 (defun riece-ruby-send-eval (program)
 146   (let* ((string (riece-ruby-escape-data program))
 147          (length (- (length string) 998))
 148          (index 0)
 149          data)
 150     (while (< index length)
 151       (setq data (cons (substring string index (setq index (+ index 998)))
 152                        data)))
 153     (setq data (cons (substring string index) data)
 154           data (nreverse data))
 155     (process-send-string riece-ruby-process "EVAL\r\n")
 156     (while data
 157       (process-send-string riece-ruby-process
 158                            (concat "D " (car data) "\r\n"))
 159       (setq data (cdr data)))
 160     (process-send-string riece-ruby-process "END\r\n")))
 161
 162 (defun riece-ruby-send-poll (name)
 163   (process-send-string riece-ruby-process
 164                        (concat "POLL " name "\r\n")))
 165
 166 (defun riece-ruby-send-exit (name)
 167   (process-send-string riece-ruby-process
 168                        (concat "EXIT " name "\r\n")))
 169
 170 (defun riece-ruby-filter (process input)
 171   (save-excursion
 172     (set-buffer (process-buffer process))
 173     (goto-char (point-max))
 174     (insert input)
 175     (goto-char (process-mark process))
 176     (beginning-of-line)
 177     (while (looking-at ".*\r\n")
 178       (if (looking-at "OK\\( \\(.*\\)\\)?\r")
 179           (progn
 180             (if riece-ruby-escaped-data
 181                 (setq riece-ruby-data (mapconcat #'riece-ruby-unescape-data
 182                                                  riece-ruby-escaped-data "")))
 183             (setq riece-ruby-escaped-data nil
 184                   riece-ruby-response (list 'OK (match-string 2))
 185                   riece-ruby-lock nil))
 186         (if (looking-at "ERR \\([0-9]+\\)\\( \\(.*\\)\\)?\r")
 187             (progn
 188               (setq riece-ruby-escaped-data nil
 189                     riece-ruby-response
 190                     (list 'ERR (string-to-number (match-string 2))
 191                           (match-string 3))
 192                     riece-ruby-lock nil))
 193           (if (looking-at "D \\(.*\\)\r")
 194               (setq riece-ruby-escaped-data (cons (match-string 1)
 195                                                   riece-ruby-escaped-data))
 196             (if (looking-at "S \\([^ ]*\\) \\(.*\\)\r")
 197                 (progn
 198                   (setq riece-ruby-status-alist (cons (cons (match-string 1)
 199                                                             (match-string 2))
 200                                                       riece-ruby-status-alist))
 201                   (if (member (car (car riece-ruby-status-alist))
 202                               '("finished" "exited"))
 203                       (riece-ruby-run-exit-handler
 204                        (cdr (car riece-ruby-status-alist)))))
 205               (if (looking-at "# output \\([^ ]*\\) \\(.*\\)\r")
 206                   (let ((entry (assoc (match-string 1)
 207                                       riece-ruby-output-handler-alist)))
 208                     (if entry
 209                         (funcall (cdr entry) (car entry) (match-string 2))))
 210                 (if (looking-at "# exit \\(.*\\)\r")
 211                     (riece-ruby-run-exit-handler (match-string 1))))))))
 212       (forward-line))
 213     (set-marker (process-mark process) (point-marker))))
 214
 215 (defun riece-ruby-run-exit-handler (name)
 216   (let ((entry (assoc name riece-ruby-exit-handler-alist)))
 217     (if entry
 218         (progn
 219           (setq riece-ruby-exit-handler-alist
 220                 (delq entry riece-ruby-exit-handler-alist))
 221           (funcall (cdr entry) (car entry))
 222           (riece-ruby-clear name)))))
 223
 224 (defun riece-ruby-sentinel (process status)
 225   (kill-buffer (process-buffer process)))
 226
 227 (defun riece-ruby-execute (program)
 228   (unless (and riece-ruby-process
 229                (eq (process-status riece-ruby-process) 'run))
 230     (let (selective-display
 231           (coding-system-for-write 'binary)
 232           (coding-system-for-read 'binary))
 233       (setq riece-ruby-process
 234             (start-process "riece-ruby" (generate-new-buffer " *Ruby*")
 235                            riece-ruby-command
 236                            (if (file-name-absolute-p riece-ruby-server-program)
 237                                riece-ruby-server-program
 238                              (expand-file-name
 239                               riece-ruby-server-program
 240                               (file-name-directory
 241                                (locate-library
 242                                 (symbol-file 'riece-ruby-execute)))))))
 243       (set-process-filter riece-ruby-process #'riece-ruby-filter)
 244       (set-process-sentinel riece-ruby-process #'riece-ruby-sentinel)))
 245   (save-excursion
 246     (set-buffer (process-buffer riece-ruby-process))
 247     (riece-ruby-reset-process-buffer)
 248     (make-local-variable 'riece-ruby-lock)
 249     (setq riece-ruby-lock t)
 250     (riece-ruby-send-eval program)
 251     (while riece-ruby-lock
 252       (accept-process-output riece-ruby-process))
 253     (if (eq (car riece-ruby-response) 'ERR)
 254         (error "Couldn't execute: %S" (cdr riece-ruby-response)))
 255     (cdr (assoc "name" riece-ruby-status-alist))))
 256
 257 (defun riece-ruby-inspect (name)
 258   (save-excursion
 259     (set-buffer (process-buffer riece-ruby-process))
 260     (riece-ruby-reset-process-buffer)
 261     (make-local-variable 'riece-ruby-lock)
 262     (setq riece-ruby-lock t)
 263     (riece-ruby-send-poll name)
 264     (while riece-ruby-lock
 265       (accept-process-output riece-ruby-process))
 266     (list riece-ruby-response
 267           riece-ruby-data
 268           riece-ruby-status-alist)))
 269
 270 (defun riece-ruby-clear (name)
 271   (save-excursion
 272     (set-buffer (process-buffer riece-ruby-process))
 273     (riece-ruby-reset-process-buffer)
 274     (make-local-variable 'riece-ruby-lock)
 275     (setq riece-ruby-lock t)
 276     (riece-ruby-send-exit name)
 277     (while riece-ruby-lock
 278       (accept-process-output riece-ruby-process)))
 279   (let ((entry (assoc name riece-ruby-property-alist)))
 280     (if entry
 281         (delq entry riece-ruby-property-alist))))
 282
 283 (defun riece-ruby-set-exit-handler (name handler)
 284   (let ((entry (assoc name riece-ruby-exit-handler-alist)))
 285     (if handler
 286         (progn
 287           (if entry
 288               (setcdr entry handler)
 289             (setq riece-ruby-exit-handler-alist
 290                   (cons (cons name handler)
 291                         riece-ruby-exit-handler-alist)))
 292           ;;check if the program already exited
 293           (riece-ruby-inspect name))
 294       (if entry
 295           (setq riece-ruby-exit-handler-alist
 296                 (delq entry riece-ruby-exit-handler-alist))))))
 297
 298 (defun riece-ruby-set-output-handler (name handler)
 299   (let ((entry (assoc name riece-ruby-output-handler-alist)))
 300     (if handler
 301         (progn
 302           (if entry
 303               (setcdr entry handler)
 304             (setq riece-ruby-output-handler-alist
 305                   (cons (cons name handler)
 306                         riece-ruby-output-handler-alist))))
 307       (if entry
 308           (setq riece-ruby-output-handler-alist
 309                 (delq entry riece-ruby-output-handler-alist))))))
 310
 311 (defun riece-ruby-set-property (name property value)
 312   (let ((entry (assoc name riece-ruby-property-alist))
 313         property-entry)
 314     (unless entry
 315       (setq entry (list name)
 316             riece-ruby-property-alist (cons entry riece-ruby-property-alist)))
 317     (if (setq property-entry (assoc property (cdr entry)))
 318         (setcdr property-entry value)
 319       (setcdr entry (cons (cons property value) (cdr entry))))))
 320
 321 (defun riece-ruby-property (name property)
 322   (cdr (assoc property (cdr (assoc name riece-ruby-property-alist)))))
 323
 324 (defun riece-ruby-exit-handler (name)
 325   (riece-ruby-inspect name)
 326   (let* ((data (copy-sequence riece-ruby-data))
 327          (length (length data))
 328          (index 0))
 329     (while (< index length)
 330       (if (eq (aref data index) ?\n)
 331           (aset data index ? ))
 332       (setq index (1+ index)))
 333     (riece-send-string
 334      (format "NOTICE %s :%s\r\n"
 335              (riece-identity-prefix
 336               (riece-ruby-property name 'riece-ruby-target))
 337              data))
 338     (riece-display-message
 339      (riece-make-message (riece-current-nickname)
 340                          (riece-ruby-property name 'riece-ruby-target)
 341                          data
 342                          'notice))))
 343
 344 (defun riece-ruby-display-message-function (message)
 345   (if (and riece-ruby-enabled
 346            (riece-message-own-p message)
 347            (string-match "^,ruby\\s-+" (riece-message-text message)))
 348       (let ((name (riece-ruby-execute
 349                    (substring (riece-message-text message)
 350                               (match-end 0)))))
 351         (riece-ruby-set-property name
 352                                  'riece-ruby-target
 353                                  (riece-message-target message))
 354         (riece-ruby-set-exit-handler name
 355                                      #'riece-ruby-exit-handler))))
 356
 357 (defun riece-ruby-insinuate ()
 358   (add-hook 'riece-after-display-message-functions
 359             'riece-ruby-display-message-function))
 360
 361 (defun riece-ruby-enable ()
 362   (setq riece-ruby-enabled t))
 363
 364 (defun riece-ruby-disable ()
 365   (setq riece-ruby-enabled nil))
 366
 367 (provide 'riece-ruby)
 368
 369 ;;; riece-ruby.el ends here