relisp 0.9.1 → 0.9.2

data/lib/relisp/{programming_types.rb → type_conversion/programming_types.rb}

@@ -43,7 +43,7 @@
 #   Macro Type::          A method of expanding an expression into another
 #                             expression, more fundamental but less pretty.
 #
-# And then these elisp types are ignored completely.
+# And then these elisp types are ignored completely, at least for now.
 #
 #   Char-Table Type::     One-dimensional sparse arrays indexed by characters.
 #   Bool-Vector Type::    One-dimensional arrays of `t' or `nil'.
@@ -182,26 +182,69 @@ module Relisp
   #
   class Cons < Proxy
 
-    # _args_ must be of the form (_symbol_, <em>slave =
-    # Relisp.default_slave</em>)
+    # _args_ can be any of these forms:
+    # * (_symbol_, <em>slave = Relisp.default_slave</em>)
+    # * (_car, _cdr_, <em>slave = Relisp.default_slave</em>)
     #
-    # The _symbol_ argument is considered to be the name of a
-    # pre-existing window in the _slave_ process.  
+    # When a _symbol_ is given it is considered to be the name of a
+    # pre-existing cons in the _slave_ process.  Otherwise a new cons
+    # is created with the given _car_ and _cdr
+    # (<tt>cons</tt>).
     #
     def initialize(*args)
-      super do 
-        raise ArgumentError, "Cannot create Cons using 'new' method."
+      super do |car, cdr|
+        @slave.elisp_exec( "(setq #{@elisp_variable} (cons #{car.to_elisp} #{cdr.to_elisp}))")
       end
     end
 
+    # Set the +car+ of Cons to be _newcar_ (+setcar+).
+    #
+    def car=(newcar)
+      @slave.setcar(@elisp_variable.value, newcar)
+    end
+
+    # Set the +cdr+ of Cons to be _newcdr_. (+setcdr+).
+    #
+    def cdr=(newcdr)
+      @slave.setcdr(@elisp_variable.value, newcdr)
+    end
+
+    # Return the +car+ of the Cons. (+car+).
+    #
     def car
       @slave.car(@elisp_variable.value)
     end
 
+    # Return the +cdr+ of the Cons. (+cdr+).
+    #
     def cdr
       @slave.cdr(@elisp_variable.value)
     end
 
+    # Return the +car+ of the +car+ of the Cons. (+caar+)
+    #
+    def caar
+      @slave.caar(@elisp_variable.value)
+    end
+
+    # Return the +car+ of the +cdr+ of the Cons. (+cadr+)
+    #
+    def cadr
+      @slave.cadr(@elisp_variable.value)
+    end
+
+    # Return the +cdr+ of the +car+ of the Cons. (+cdar+)
+    #
+    def cdar
+      @slave.cadr(@elisp_variable.value)
+    end
+
+    # Return the +cdr+ of the +cdr+ of the Cons. (+cddr+)
+    #
+    def cddr
+      @slave.cadr(@elisp_variable.value)
+    end
+
     # This function will NOT return true whenever the elisp function
     # <tt>listp</tt> is true.  The elisp function is true whenever the
     # object is a cons cell, but this method is true only when the
@@ -240,6 +283,8 @@ module Relisp
       end
     end
 
+    alias to_a to_list
+
   end
 
 
@@ -296,9 +341,9 @@ module Relisp
       end
       keys_var = slave.new_elisp_variable
       vals_var = slave.new_elisp_variable
-      slave.elisp_execute( "(setq #{keys_var} nil)" )
-      slave.elisp_execute( "(setq #{vals_var} nil)" )
-      slave.elisp_execute( "(maphash (lambda (key val)
+      slave.elisp_exec( "(setq #{keys_var} nil)" )
+      slave.elisp_exec( "(setq #{vals_var} nil)" )
+      slave.elisp_exec( "(maphash (lambda (key val)
                               (setq #{keys_var} (append #{keys_var} (list key)))
                               (setq #{vals_var} (append #{vals_var} (list val)))) #{object_variable})" )
       keys = slave.elisp_eval( keys_var )
@@ -388,7 +433,7 @@ class Array
       object_array << object[:slave].elisp_eval( "(elt #{object_variable} #{i.to_elisp})" )
     end
 
-    object[:slave].elisp_execute( "(makunbound #{object_variable.to_elisp})" )
+    object[:slave].elisp_exec( "(makunbound #{object_variable.to_elisp})" )
     return object_array
   end
 

data/lib/relisp/type_conversion.rb

@@ -0,0 +1,60 @@
+module Relisp
+
+  # Proxy contains the code that creates a wrapper around a variable
+  # in emacs.
+  #
+  class Proxy
+    def self.from_elisp(object)
+      new(object[:variable], object[:slave])
+    end
+
+    # If the last argument is a Relisp::Slave, it gets pulled off and
+    # used as the slave; otherwise Relisp.default_slave is used.  If
+    # the first argument is a Symbol, it is assumed to be the name of
+    # an elisp variable which needs a proxy.  If the first argument
+    # isn't a Symbol, all of the arguments (except the last, if it was
+    # a Slave) are send off to the child to handle.
+    #
+    def initialize(*args)
+      @slave = if args.last.kind_of?(Relisp::Slave)
+                 args.pop
+               else
+                 Relisp.default_slave
+               end
+
+      if args[0].kind_of?(Symbol) && args[1].nil?
+        @elisp_variable = @slave.get_permanent_variable(args[0])
+        elisp_type= ""
+        self.class.to_s.split("::").last.split(//).each_with_index do |char, index|
+          unless index==0 || char == char.downcase
+            elisp_type << "-"
+          end
+          elisp_type << char.downcase
+        end
+
+        unless @slave.elisp_eval("(type-of #{@elisp_variable})") == elisp_type.to_sym
+          raise ArgumentError, "#{@elisp_variable} isn't a #{elisp_type}"
+        end
+      else
+        @elisp_variable = @slave.new_elisp_variable
+        yield args
+      end
+    end
+  
+    attr_reader :slave, :elisp_variable
+
+    def to_elisp
+      @elisp_variable
+    end
+
+    private 
+    
+    def call_on_self(function, *args)
+      @slave.send(function, @elisp_variable.value, *args)
+    end
+  end
+
+end
+
+require 'relisp/type_conversion/editing_types'
+require 'relisp/type_conversion/programming_types'

data/lib/relisp.rb

@@ -19,12 +19,11 @@
 #++
 
 module Relisp
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
 
   class ElispError < RuntimeError; end
 end
 
-require 'relisp/editing_types'
-require 'relisp/elisp_functions.rb'
-require 'relisp/programming_types'
+require 'relisp/type_conversion'
+require 'relisp/elisp_functions'
 require 'relisp/slaves'

data/manual_test/tests.el

@@ -0,0 +1,72 @@
+(progn
+  (relisp-stop-slave)
+  (setq relisp-ruby-slave-path "tests.rb")
+  (relisp-start-slave))
+
+;; bury current buffer
+(ruby-eval "buffer_bury")
+
+;; split this window vertically and set bottow window to
+;; 'other-buffer'
+(ruby-eval "buffer_window_equals")
+
+;; split this window vertically then horizontally
+(ruby-eval "window_split")
+
+;; should move text up and return nil
+(ruby-eval "window_scroll_up")
+
+;; should move text down and return t
+(ruby-eval "window_scroll_down")
+
+;; create some windows and move them horizontally and vertically
+(ruby-eval "window_shrink")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/manual_test/tests.rb

@@ -0,0 +1,66 @@
+$:.unshift File.join(File.dirname(__FILE__), "../lib") 
+
+require 'relisp'
+
+slave = Relisp::RubySlave.new
+
+def buffer_bury
+  b = current_buffer
+  b.bury
+end
+
+def buffer_window_equals
+  w = split_window_vertically
+  b = other_buffer
+  b.window = w
+end
+
+def window_split
+  w = selected_window
+  new_window = w.split_vertically
+  new_window.split_horizontally
+end
+
+def window_scroll_up
+  selected_window.scroll_up(1)
+  selected_window.visible?(1)
+end
+
+def window_scroll_down
+  selected_window.scroll_down(1)
+  selected_window.visible?(1)
+end
+
+
+def window_shrink
+  w = selected_window
+  w2 = w.split_vertically
+  w3 = w2.split_horizontally
+  10.times do
+    w.shrink(1)
+    redisplay
+    sleep 0.01
+  end
+  10.times do
+    w.enlarge(1)
+    redisplay
+    sleep 0.01
+  end
+  10.times do
+    w2.shrink(0,1)
+    redisplay
+    sleep 0.01
+  end
+  10.times do
+    w2.enlarge(0,1)
+    redisplay
+    sleep 0.01
+  end
+  
+  w2.delete
+  w3.delete
+end
+
+
+slave.start
+

data/src/relisp.el

@@ -61,8 +61,10 @@
 (defvar relisp-emacs-master-p t)
 (defvar relisp-slave-process)
 (defvar relisp-ruby-output)
-(defvar relisp-question-code)
+(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-previous-result)
@@ -111,26 +113,55 @@
 (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 "ruby> ")
+  (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 "sruby> ")
+  (interactive "ruby> ")
   (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-read-from-ruby))
-    (while (string-match relisp-question-code message)
-      (relisp-answer-ruby message)
-      (setq message (relisp-read-from-ruby)))
+    (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)
@@ -149,15 +180,35 @@ given."
       (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-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-form-question (code)
+(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))))))
+
+(defun relisp-form-command (code)
   "Return a string that tells ruby to evaluate CODE."
+  (unless (stringp code)
+    (setq code (prin1-to-string code)))
+  (concat code "\n" relisp-command-code))
+
+(defun relisp-form-question (code)
+  "Return a string that tells ruby to evaluate CODE and return the result."
   (unless (stringp code)
     (setq code (prin1-to-string code)))
   (concat code "\n" relisp-question-code))
@@ -178,6 +229,31 @@ given."
     (set var object)
     (concat "elisp_eval('" (prin1-to-string var) "')")))
 
+(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 "")))
+
+(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 nil
   "Start a ruby slave process to do emacs's bidding.
 If `relisp-ruby-slave-path' is bound, then that file is read and
@@ -200,26 +276,7 @@ emacs starts a ruby process and starts a RubySlave on its own."
 				 "Relisp::RubySlave.new.start\n"
 				 "__END__\n")))
   (set-process-filter relisp-slave-process 'relisp-slave-output-filter)
-  (relisp-write-to-ruby "")
-  (while (null (string-match "\n" relisp-ruby-output))
-    (accept-process-output))
-  (setq relisp-answer-code (relisp-strip relisp-ruby-output))
-  (setq relisp-ruby-output "")
-  (relisp-write-to-ruby "")
-  (while (null (string-match "\n" relisp-ruby-output))
-    (accept-process-output))
-  (setq relisp-question-code (relisp-strip relisp-ruby-output))
-  (setq relisp-ruby-output "")
-  (relisp-write-to-ruby "")
-  (while (null (string-match "\n" relisp-ruby-output))
-    (accept-process-output))
-  (setq relisp-error-code (relisp-strip relisp-ruby-output))
-  (setq relisp-ruby-output "")
-  (relisp-write-to-ruby "")
-  (while (null (string-match "\n" relisp-ruby-output))
-    (accept-process-output))
-  (setq relisp-previous-result (read (relisp-strip relisp-ruby-output)))
-  (setq relisp-ruby-output "")
+  (relisp-get-constants)
   relisp-slave-process)
 
 (defun relisp-become-slave nil
@@ -227,23 +284,18 @@ emacs starts a ruby process and starts a RubySlave on its own."
   (setq relisp-emacs-master-p nil)
   ;; get constants
   (message "SEND CONSTANTS")
-  (message "(prompt for answer code)")
-  (setq relisp-answer-code (read-from-minibuffer ""))
-  (message "(prompt for question code)")
-  (setq relisp-question-code (read-from-minibuffer ""))
-  (message "(prompt for error code)")
-  (setq relisp-error-code (read-from-minibuffer ""))
-  (message "(prompt for previous result variable)")
-  (setq relisp-previous-result (read (read-from-minibuffer "")))
+  (relisp-get-constants)
   (let (input input-line)
     (while t ;; loop is only a CL function, I guess
       (setq input "")
       (setq input-line "")
-      (while (null (string-match relisp-question-code (relisp-strip 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)))
-      (relisp-answer-ruby input))))
-
+      (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'."
@@ -259,7 +311,6 @@ emacs starts a ruby process and starts a RubySlave on its own."
   (and (boundp 'relisp-slave-process) 
        (equal (process-status relisp-slave-process) 'run)
        (boundp 'relisp-question-code)
-       (boundp 'relisp-answer-code)
        (boundp 'relisp-error-code)))
 
 (provide 'relisp)