relisp 1.0.1 → 1.1.0

data/src/relisp.el

@@ -1,12 +1,17 @@
 ;;; relisp.el --- library for ruby/elisp interaction
 
-;; Copyright (C) 2009 <don@ohspite.net>
+;; Copyright (C) 2009, 2010 Don March
+
+;; Author: Don March <don@ohspite.net>
+;; Created: 2009-01-25
+;; Version: 1.1.0
+;; Keywords: ruby emacs elisp bridge
 
 ;; This file is part of Relisp.
 
 ;; Relisp 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
+;; the Free Software Foundation; either version 3 of the License, or
 ;; (at your option) any later version.
 
 ;; Relisp is distributed in the hope that it will be useful, but
@@ -19,188 +24,101 @@
 ;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 ;; 02110-1301 USA
 
+;;; Code: 
 
-;; TODO:
-;; signal errors when ruby returns an error?
-
-
-;;; first, some general string functions
-
-(defun relisp-trim-leading-whitespace (str)
-  "Remove leading whitespace characters from STR."
-  (let ((s (if (symbolp str)(symbol-name str) str))
-	(whitespace-regexp "\\( \\|\f\\|\t\\|\n\\)"))
-    (save-excursion
-      (while (and
-	      (not (null (string-match (concat "^" whitespace-regexp) s)))
-	      (> (length s) (string-match (concat "^" whitespace-regexp) s)))
-	(setq s (replace-match "" t nil s))))
-    s))
-
-(defun relisp-trim-trailing-whitespace (str)
-  "Remove trailing whitespace characters from STR."
-  (let ((s (if (symbolp str)(symbol-name str) str))
-	(whitespace-regexp "\\( \\|\f\\|\t\\|\n\\)"))
-    (save-excursion
-      (while (and
-	      (not (null (string-match (concat whitespace-regexp "$") s)))
-	      (> (length s) (string-match (concat whitespace-regexp "$") s)))
-	(setq s (replace-match "" t nil s))))
-    s))
-
-(defun relisp-strip (str)
-  "Remove leading and trailing whitespace from STR."
-  (relisp-trim-leading-whitespace (relisp-trim-trailing-whitespace str)))
-
-;;; now real stuff
-
-(defvar relisp-slave-name "relisp-slave" "Name of the relisp ruby slave process.")
-(defvar relisp-buffer-name "*Relisp*" "Name of the relisp output buffer.")
+(defvar relisp-slave-name "relisp-slave" 
+  "Name of the relisp ruby slave process.")
+(defvar relisp-buffer-name "*Relisp*" 
+  "Name of the relisp output buffer.")
+(defvar relisp-endofmessage-regexp nil
+  "A regexp that matches codes indicating a message termination.")
 
 ;; to prohibit free variable warnings
 (defvar relisp-emacs-master-p t)
 (defvar relisp-slave-process)
-(defvar relisp-ruby-output)
 (defvar relisp-begin-answer-code)
 (defvar relisp-answer-code)
 (defvar relisp-question-code)
 (defvar relisp-command-code)
 (defvar relisp-error-code)
-(defvar relisp-ruby-return)
+(defvar relisp-begin-slave-code)
 (defvar relisp-previous-result)
 
-(defun relisp-log (text)
-  "Insert TEXT at the end of `relisp-buffer-name', unless emacs is the slave."
-  (save-excursion
-    (when relisp-emacs-master-p
-      (get-buffer-create relisp-buffer-name)
-      (unless (string-match (relisp-endofmessage-regexp) (relisp-strip text))
-	(set-buffer relisp-buffer-name)
-	(goto-char (point-max))
-	(insert text "\n")))))
+(put 'relisp-ruby-error 
+     'error-conditions '(error relisp-ruby-error))
+(put 'relisp-ruby-error
+     'error-message "Error in ruby process")
 
-(defun relisp-write-to-ruby (message)
-  "Send MESSAGE to the ruby process."
+(defun relisp-ruby-send (message &optional process)
+  "Send MESSAGE to the slave or master ruby PROCESS.
+PROCESS defaults to `relisp-slave-process' when nil."
   (if relisp-emacs-master-p
-      (process-send-string relisp-slave-process (concat message "\n"))
+      (progn 
+	(or process (setq process relisp-slave-process))
+	(process-send-string process (concat message "\n")))
     (message message)))
 
-(defun relisp-read-from-ruby nil
-  "Accept ruby input, stopping at a match to `relisp-endofmessage-regexp'."
-  (if relisp-emacs-master-p
-      (relisp-accept-slave-output)
-    (relisp-accept-master-output)))
-    
-(defun relisp-accept-slave-output nil
-  "Accept a full ruby message when ruby is the slave process."
-  (while (and (relisp-slave-alive-p) 
-	      (null (string-match (relisp-endofmessage-regexp)
-				  relisp-ruby-output)))
-    (accept-process-output))
-  (let ((val relisp-ruby-output))
-    (setq relisp-ruby-output "")
-    val))
-
-(defun relisp-accept-master-output nil
-  "Accept a full ruby message when emacs is the slave process."
-  (let ((output "") 
-	(output-line ""))
-    (while (null (string-match (relisp-endofmessage-regexp) output-line))
-      (setq output-line (read-from-minibuffer ""))
-      (setq output (concat output output-line)))
+(defun relisp-ruby-slave-read (&optional process terminator-regexp)
+  "Accept a full message from ruby slave."
+  (or process (setq process relisp-slave-process))
+  (or terminator-regexp
+      (setq terminator-regexp relisp-endofmessage-regexp))
+  (let ((buffer (process-buffer process)))
+    (with-current-buffer buffer
+      (delete-region (point-min) (point-max)))
+    (while (and (relisp-slave-alive-p process)
+		(not (string-match terminator-regexp
+				   (with-current-buffer buffer (buffer-string)))))
+      (accept-process-output process nil nil t))
+    (with-current-buffer buffer (buffer-string))))
+
+(defun relisp-ruby-master-read (&optional terminator-regexp)
+  "Accept a full message from ruby master."
+  (or terminator-regexp
+      (setq terminator-regexp relisp-endofmessage-regexp))
+  (let ((output ""))
+    (while (not (string-match terminator-regexp output))
+      (setq output (concat output (read-from-minibuffer ""))))
     output))
 
-(defun relisp-endofmessage-regexp nil
-  "Return a regexp that matches codes indicating a message termination."
-  (concat "\\(" relisp-question-code 
-	  "\\|" relisp-command-code 
-	  "\\|" relisp-answer-code 
-	  "\\|" relisp-error-code
-	  "\\)" 
-	  "[[:space:]]*"))
-
-(defun relisp-receive-answer nil
-  "Handle messages from emacs after ruby-eval or ruby-exec are called."
-  (let ((message (relisp-read-from-ruby)))
-    (while (or (string-match relisp-question-code message)
-	       (string-match relisp-command-code  message))
-      (if (string-match relisp-question-code message)
-	  (relisp-answer-ruby message)
-	(relisp-obey-ruby message))
-      (setq message (relisp-read-from-ruby)))
-    message))
-
-(defun ruby-exec (ruby-code)
-  "Have ruby evaluate RUBY-CODE without returning the result.
-Reads input from the minibuffer unless an argument is
-given."
-  (interactive "Mruby> ")
-  (let (message result)
-    (if (and relisp-emacs-master-p (not (relisp-slave-alive-p)))
-	(relisp-start-slave))
-    (relisp-log (concat "lisp!> " ruby-code))
-    (relisp-write-to-ruby (relisp-form-command ruby-code))
-    (setq message (relisp-receive-answer))
-    (setq relisp-ruby-return (relisp-strip (car (split-string message relisp-answer-code))))
-    (relisp-log "")
-    (setq result (if (string-match (concat "\n?" relisp-error-code "[[:space:]]*") relisp-ruby-return)
-		     (concat "RUBY ERROR: " (replace-match "" nil t relisp-ruby-return))
-		   nil))
-    (if (and (interactive-p) (not (null result)))
-	(message (prin1-to-string result)))
-    result))
-
-(defun ruby-eval (ruby-code)
-  "Have ruby evaluate RUBY-CODE and return the result.
-The result is an elisp object equivalent to the ruby result of
-RUBY-CODE.  Reads input from the minibuffer unless an argument is
-given."
-  (interactive "Mruby> ")
-  (let (message result)
-    (if (and relisp-emacs-master-p (not (relisp-slave-alive-p)))
-	(relisp-start-slave))
-    (relisp-log (concat "lisp?> " ruby-code))
-    (relisp-write-to-ruby (relisp-form-question ruby-code))
-    (setq message (relisp-receive-answer))
-    (setq relisp-ruby-return (relisp-strip (car (split-string message relisp-answer-code))))
-    (relisp-log (concat "ruby=> " relisp-ruby-return "\n"))
-    (setq result (if (string-match (concat "\n?" relisp-error-code "[[:space:]]*") relisp-ruby-return)
-		     (concat "RUBY ERROR: " (replace-match "" nil t relisp-ruby-return))
-		   (eval (read (relisp-trim-trailing-whitespace relisp-ruby-return)))))
-    (if (interactive-p) 
-	(message (prin1-to-string result)))
-    result))
-
-(defun relisp-answer-ruby (question)
-  "Evaluate the QUESTION from ruby and send ruby the result."
-  (setq question (relisp-strip (car (split-string question relisp-question-code))))
-  (relisp-log (concat "ruby?> " question))
-  (setq question (read question))
-  (condition-case error-description
+(defun relisp-ruby-read (&optional process terminator-regexp)
+  "Accept ruby message, stopping at a match to TERMINATOR-REGEXP."
+  (if relisp-emacs-master-p
       (progn 
-	(set relisp-previous-result (eval question))
-	(relisp-log (concat "lisp=> " (prin1-to-string (type-of (eval relisp-previous-result)))))
-	(relisp-log (concat "    => " (prin1-to-string (eval relisp-previous-result))))
-	(relisp-write-to-ruby relisp-begin-answer-code)
-	(relisp-write-to-ruby (prin1-to-string (type-of (eval relisp-previous-result))))
-	(relisp-write-to-ruby (relisp-form-answer (eval relisp-previous-result))))
-    (error (relisp-write-to-ruby 
-	    (relisp-form-error
-	     (error-message-string error-description))))))
-
-(defun relisp-obey-ruby (command)
-  "Evaluate the COMMAND from ruby."
-  (setq command (relisp-strip (car (split-string command relisp-command-code))))
-  (relisp-log (concat "ruby!> " command))
-  (setq command (read command))
-  (condition-case error-description
-      (progn
-	(set relisp-previous-result (eval command))
-	(relisp-write-to-ruby relisp-answer-code))
-    (error (relisp-write-to-ruby 
-	    (relisp-form-error
-	     (error-message-string error-description))))))
+	(relisp-ruby-slave-read process terminator-regexp))
+    (relisp-ruby-master-read terminator-regexp)))
+
+;; From here on out, no more process stuff
+
+(defun relisp-strip (str &optional side)
+  "Return STR stripped of leading and/or trailing whitespace.
+
+If SIDE is 'start (or 'leading) or 'end (or 'trailing), only trim
+whitespace on that side of the string."  
+  (when (not (memq side '(end trailing)))
+    (when (string-match "^[\n\t\r\f\v ]+" str)
+      (setq str (replace-match "" nil nil str))))
+  (when (not (memq side '(start leading)))
+    (when (string-match "[\n\t\r\f\v ]+$" str)
+      (setq str (replace-match "" nil nil str))))
+  str)
+
+(defun relisp-log (&optional text)
+  "Insert TEXT at the end of the log buffer, when emacs is mater."
+  (or text (setq text ""))
+  (when (and relisp-emacs-master-p
+	     (if (and (boundp 'relisp-endofmessage-regexp)
+		      relisp-endofmessage-regexp)
+		 (and (not (string-match relisp-endofmessage-regexp (relisp-strip text)))
+		      (not (string-match relisp-begin-slave-code (relisp-strip text))))
+	       t)
+      (with-current-buffer (get-buffer-create relisp-buffer-name)
+	(goto-char (point-max))
+	(insert text "\n")))))
 
+;; relisp-form-command and -question convert the argument to a string,
+;; if necessary, to catch end cases like `nil', but -form-answer and
+;; -error always take raw code as arguments.
 (defun relisp-form-command (code)
   "Return a string that tells ruby to evaluate CODE."
   (unless (stringp code)
@@ -224,94 +142,179 @@ given."
   (concat code "\n" relisp-error-code))
 
 (defun relisp-to-ruby (object)
-  "Return a string that, when evaluated in ruby, results in OBJECT."
+  "Return a string that, when evaluated in ruby, results in OBJECT.
+This function is deprecated."
   (let ((var (ruby-eval "new_elisp_variable")))
     (set var object)
     (concat "elisp_eval('" (prin1-to-string var) "')")))
 
+(defun relisp-ruby-receive (&optional process safe)
+  "Handle messages from emacs after ruby-eval or ruby-exec are called."
+  (let ((message (relisp-ruby-read process))
+	question)
+    (while (or (setq questionp (string-match relisp-question-code message))
+	       (string-match relisp-command-code  message))
+      (relisp-exec (relisp-strip (car (split-string message relisp-endofmessage-regexp)))
+		   questionp)
+      (setq message (relisp-ruby-read process)))
+    (setq message (relisp-strip (car (split-string message relisp-answer-code))))
+    (relisp-log (concat "ruby=> " message "\n"))
+    (when (and (not safe) (string-match relisp-error-code message))
+      (signal 'relisp-ruby-error (list (replace-match "" nil t message))))
+    message))
+
+(defun ruby-exec (ruby-code &optional process return)
+  "Have ruby evaluate RUBY-CODE, returning result if RETURN is non-nil.
+The result is an elisp object equivalent to the ruby result of
+RUBY-CODE.  Reads input from the minibuffer unless an argument is
+given."
+  (interactive "Mruby> ")
+  (let (result)
+    (if (and relisp-emacs-master-p (not (relisp-slave-alive-p)))
+	(relisp-start-slave))
+    (relisp-log (concat "lisp" 
+			(if return "?" "!")
+			"> " ruby-code))
+    (relisp-ruby-send (if return
+			  (relisp-form-question ruby-code)
+			(relisp-form-command ruby-code))
+		      process)
+    (setq result (if return (eval (read (relisp-ruby-receive process)))
+		   (relisp-ruby-receive process)))
+    (when (and return (interactive-p))
+      (message (prin1-to-string result)))
+    result))
+
+(defun ruby-eval (ruby-code &optional process)
+  "Have ruby evaluate RUBY-CODE and return the result."
+  (ruby-exec ruby-code process t))
+
+(defun relisp-exec (lisp-code &optional return)
+  "Evaluate the LISP-CODE from ruby.
+Send ruby the result if RETURN is non-nil."
+  (relisp-log (concat (if return "ruby?> " "ruby! ")
+		      lisp-code))
+  (setq lisp-code (read lisp-code))
+  (condition-case error-description
+      (progn
+	(set relisp-previous-result (eval lisp-code))
+	(if (not return)
+	    (relisp-ruby-send (relisp-form-answer nil))
+	  (relisp-log (concat "lisp=> " 
+			      (prin1-to-string (type-of (symbol-value relisp-previous-result)))))
+	  (relisp-log (concat "    => " 
+			      (prin1-to-string (symbol-value relisp-previous-result))))
+	  (relisp-ruby-send relisp-begin-answer-code)
+	  (relisp-ruby-send (prin1-to-string (type-of (symbol-value relisp-previous-result))))
+	  (relisp-ruby-send (relisp-form-answer (symbol-value relisp-previous-result)))))
+    (error (relisp-ruby-send 
+	    (relisp-form-error
+	     (error-message-string error-description))))))
+
+(defun relisp-eval (lisp-code)
+  "Evaluate the LISP-CODE from ruby and send ruby the result."
+  (relisp-exec lisp-code t))
+
 (defun relisp-get-constant nil
   "Return the next constant passed from ruby.
 Intended to be called from relisp-get-constants."
-  (if relisp-emacs-master-p
-      (progn
-	(relisp-write-to-ruby "(prompt)")
-	(while (null (string-match "\n" relisp-ruby-output))
-	  (accept-process-output))
-	(let ((result (relisp-strip relisp-ruby-output)))
-	  (setq relisp-ruby-output "")
-	  result))
-    (message "(prompt)")
-    (read-from-minibuffer "")))
+  (relisp-ruby-send "(prompt)")
+  (relisp-strip (relisp-ruby-read nil 
+				  (if relisp-emacs-master-p 
+				      "\n" 
+				    "."))))
 
 (defun relisp-get-constants nil
   "Sets all relisp constants shared between ruby and emacs.
 Intended to be called from relisp-start-slave and
 relisp-become-slave."
-  (setq relisp-question-code     (relisp-get-constant))
-  (setq relisp-command-code      (relisp-get-constant))
-  (setq relisp-begin-answer-code (relisp-get-constant))
-  (setq relisp-answer-code       (relisp-get-constant))
-  (setq relisp-error-code        (relisp-get-constant))
-  (setq relisp-previous-result   (read (relisp-get-constant))))
-
-(defun relisp-start-slave (&optional slave-path)
+  (when (not relisp-emacs-master-p)
+    (relisp-ruby-send "SEND CONSTANTS"))
+  (setq relisp-question-code     (relisp-get-constant)
+	relisp-command-code      (relisp-get-constant)
+	relisp-begin-answer-code (relisp-get-constant)
+	relisp-answer-code       (relisp-get-constant)
+	relisp-error-code        (relisp-get-constant)
+	relisp-begin-slave-code  (relisp-get-constant)
+	relisp-previous-result   (read (relisp-get-constant)))
+  (relisp-ruby-send "(got constants)")
+  (setq relisp-endofmessage-regexp 
+	(concat relisp-question-code "\\|" 
+		relisp-command-code "\\|" 
+		relisp-answer-code "\\|" 
+		relisp-error-code)))
+
+(defun relisp-start-slave (&optional slave-path new)
   "Start a ruby slave process to do emacs's bidding.
 If SLAVE-PATH is given, then that Ruby file is read and the
 Relisp::RubySlave object must be started in that file.  Otherwise
 emacs starts a ruby process and starts a RubySlave on its own."
   (interactive)
   (setq relisp-emacs-master-p t)
-  (relisp-stop-slave)
-  (setq relisp-ruby-output "")
-  (if (and slave-path (file-exists-p slave-path))
-      (setq relisp-slave-process (start-process relisp-slave-name nil "ruby" slave-path))
+  (unless new (relisp-stop-slave))
+  (if (and slave-path 
+	   (not (string= slave-path "")))
+      (if (file-exists-p slave-path)
+	  (setq relisp-slave-process (start-process relisp-slave-name nil "ruby" slave-path))
+	(error (concat "Ruby slave does not exist: " slave-path)))
     (setq relisp-slave-process (start-process relisp-slave-name nil
 					      "ruby" 
+					      "-rubygems"
 					      "-x"))
-    (process-send-string relisp-slave-name 
-			 (concat "#! ruby \n"
+    (process-send-string relisp-slave-process
+			 ; with `-x' ruby ignores everything until a
+			 ; line with `#! ruby'.
+			 (concat "#! ruby"
+				 ;; something really weird is going on
+				 ;; with the bindings here; if you
+				 ;; comment out any of the next 3
+				 ;; lines then $: isn't set
+				 ;; properly. `$__RELISP__' is a
+				 ;; throwaway variable.
 				 "$:.unshift File.join(File.dirname('" (symbol-file 'relisp-slave-name) "'), '../lib')\n"
-				 "require 'rubygems'\n" 
+				 "$__RELISP__=$:\n"
+				 "$__RELISP__.unshift File.join(File.dirname('" (symbol-file 'relisp-slave-name) "'), '../lib')\n"
 				 "require 'relisp'\n" 
 				 "Relisp::RubySlave.new.start\n"
 				 "__END__\n")))
-  (set-process-filter relisp-slave-process 'relisp-slave-output-filter)
+  (set-process-buffer relisp-slave-process 
+		      (generate-new-buffer (concat " " (process-name relisp-slave-process))))
   (relisp-get-constants)
+  (relisp-log (concat "started: " (prin1-to-string relisp-slave-process)))
+  ; gobble up initial ruby messages and respond 
+  (while (and (relisp-slave-alive-p) 
+	      (not (string= relisp-begin-slave-code
+			    (relisp-ruby-receive relisp-slave-process)))))
+  (if (relisp-slave-alive-p)
+      (relisp-log (concat "startup finished: " (prin1-to-string relisp-slave-process)))
+    (relisp-log (concat "finished: " (prin1-to-string relisp-slave-process))))
   relisp-slave-process)
 
 (defun relisp-become-slave nil
   "Convert the emacs process into a slave.  Only called by ruby."
   (setq relisp-emacs-master-p nil)
-  ;; get constants
-  (message "SEND CONSTANTS")
   (relisp-get-constants)
-  (let (input input-line)
-    (while t ;; loop is only a CL function, I guess
-      (setq input "")
-      (setq input-line "")
-      (while (and (null (string-match relisp-question-code (relisp-strip input-line)))
-		  (null (string-match relisp-command-code  (relisp-strip input-line))))
-	(setq input-line (read-from-minibuffer ""))
-	(setq input (concat input input-line)))
-      (if (string-match relisp-question-code (relisp-strip input-line))
-	  (relisp-answer-ruby input)
-	(relisp-obey-ruby input)))))
-
-(defun relisp-slave-output-filter (process output-line)
-  "Listen to PROCESS and add each OUTPUT-LINE to `relisp-ruby-output'."
-  (setq relisp-ruby-output (concat relisp-ruby-output output-line)))
-
-(defun relisp-stop-slave nil
-  "Kill the ruby slave process."
-  (interactive)
-  (if (boundp 'relisp-slave-process)
-      (delete-process relisp-slave-process)))
+  (while t ;; loop is only a CL function, I guess
+    (relisp-ruby-receive nil t)))
 
-(defun relisp-slave-alive-p nil
-  "Return t if the ruby slave is alive and well."
-  (and (boundp 'relisp-slave-process) 
-       (equal (process-status relisp-slave-process) 'run)
-       (boundp 'relisp-question-code)
-       (boundp 'relisp-error-code)))
+(defun relisp-stop-slave (&optional process)
+  "Kill the ruby slave PROCESS."
+  (interactive)
+  (or process (if (boundp 'relisp-slave-process) 
+		  (setq process relisp-slave-process)))
+  (when (and process
+	     (relisp-slave-alive-p process))
+    (kill-buffer (process-buffer process))
+    (relisp-log (concat "stopped: " (prin1-to-string process)))
+    (delete-process process)))
+      
+(defun relisp-slave-alive-p (&optional process)
+  "Return whether the ruby slave PROCESS is alive and well."
+  (if process
+      (equal (process-status process) 'run)
+    (and (boundp 'relisp-slave-process)
+	 (equal (process-status relisp-slave-process) 'run))))
 
 (provide 'relisp)
+
+;;; relisp.el ends here

data/test/test_editing_types.rb

@@ -31,7 +31,7 @@ module TestRelisp
       test_buffer_name = "*relisp-test-buffer*"
       buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
       assert_kind_of Relisp::Buffer, buffer
-      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |buffer| buffer.name } 
+      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |b| b.name } 
       assert buffer_names.include?(test_buffer_name)
     end
 
@@ -61,7 +61,7 @@ module TestRelisp
       test_buffer_name = "*relisp-test-buffer*"
       buffer = @emacs.elisp_eval( "(create-file-buffer \"#{test_buffer_name}\") " )
       assert_kind_of Relisp::Buffer, buffer
-      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |buffer| buffer.name } 
+      buffer_names = @emacs.elisp_eval( '(buffer-list)' ).to_list.map { |b| b.name } 
       assert buffer_names.include?(test_buffer_name)
     end
 
@@ -488,7 +488,8 @@ module TestRelisp
 
   class TestFrame < Test::Unit::TestCase
     def setup
-      @emacs = Relisp::ElispSlave.new
+#      @emacs = Relisp::ElispSlave.new
+      @emacs = EMACS
     end
 
     def test_class_from_elisp

data/test/test_elisp_functions.rb

@@ -28,7 +28,6 @@ module TestRelisp
       assert_equal start_point, @emacs.point
       assert_equal start_buffer.name, @emacs.current_buffer.name
     end
-
     def test_method_missing
       assert_equal 6, @emacs.+(1, 2, 3)
       assert_raise NameError do

data/test/test_programming_types.rb

@@ -128,8 +128,10 @@ module TestRelisp
     end
 
      def test_initialize
-       new_cons = Relisp::Cons.new(1, 2)
+       new_cons = Relisp::Cons.new(4, 5, @emacs)
        assert_equal :cons, @emacs.type_of(new_cons)
+       assert_equal 4, new_cons.car
+       assert_equal 5, new_cons.cdr
      end
 
     def test_car
@@ -167,10 +169,9 @@ module TestRelisp
       result = @emacs.elisp_eval( "'(1 2 3)" ).to_list
       assert_equal [1, 2, 3], result
       result = @emacs.elisp_eval( "'(1 . 2)" )      
-      assert ! result.to_list
+      assert_raise(RuntimeError) { result.to_list }
     end
-
-   end
+  end
 
   class TestList < Test::Unit::TestCase
     def setup

data/test/test_slaves.rb

@@ -5,11 +5,12 @@ require 'test/unit' unless defined? $ZENTEST and $ZENTEST
 $:.unshift File.dirname(__FILE__) + "/../lib" 
 require 'relisp'
 
-EMACS = Relisp::ElispSlave.new unless defined? EMACS
+EMACS ||= Relisp::ElispSlave.new
 
 module TestRelisp
   class TestElispSlave < Test::Unit::TestCase
     def setup
+      # @emacs = Relisp::ElispSlave.new
       @emacs = EMACS
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: relisp
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 1
-  - 0
   - 1
-  version: 1.0.1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Don
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-31 00:00:00 -05:00
+date: 2011-01-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,8 +49,13 @@ files:
 - README
 - Rakefile
 - examples/elisp_master/elisp_master.el
-- examples/elisp_master/ruby_slave
-- examples/ruby_master/ruby_master_example
+- examples/elisp_master/ruby_slave.rb
+- examples/elisp_master/ruby_slave2.rb
+- examples/ruby_master/basic.rb
+- examples/ruby_master/debugging.rb
+- examples/ruby_master/elisp_data_types.rb
+- examples/ruby_master/method_missing.rb
+- examples/ruby_master/recursive_calling.rb
 - lib/relisp.rb
 - lib/relisp/elisp_functions.rb
 - lib/relisp/slaves.rb
@@ -59,7 +64,6 @@ files:
 - lib/relisp/type_conversion/programming_types.rb
 - manual_test/tests.el
 - manual_test/tests.rb
-- setup.rb
 - src/relisp.el
 - test/test_editing_types.rb
 - test/test_elisp_functions.rb
@@ -76,13 +80,14 @@ post_install_message: |
   The gem is installed, and you can now call elisp from ruby.  But if
   you want to call ruby from emacs (and you do, right?) you need to go
   into the 'src' directory of this gem and copy 'relisp.el' and/or
-  'relisp.elc' to your elisp folder (probably '~/.elisp').  Then you
-  might want to add the lines
+  'relisp.elc' to your elisp folder (probably something like
+  '~/.emacs.d/site-lisp' or '~/.elisp').  Then you might want to add the
+  lines
   
     (autoload 'relisp-start-slave "relisp" nil t)
     (autoload 'ruby-eval "relisp" nil t)
   
-  to your emacs initialization file (probably '~/.emacs').
+  to your emacs initialization file ('~/.emacs' or ~/.emacs.d/init.el).
   
   If you don't know where to find the files for this gem, run the
   command "gem env gemdir".  Or you can download the tarball for this